Объект Middleman для управления доступом?

Question

У меня есть два класса:

class World { 
public: 
     void update(); 
     void addObject(GameObject* obj); 
     std::vector<GameObject const*> getGameObjectsAt(float x,float y,float radius) const; 
private: 
     std::vector<GameObject*> gameObjects 
} 

class GameObject { 
public: 
    void update(); 
} 

Теперь я хочу GameObject быть в состоянии назвать getGameObjectsAt и addObject из World в update функции. Однако я не хочу, чтобы GameObject мог позвонить функции updateWorld.

---

Я мог бы сделать новый класс WorldSomething, содержащие мой World объект и имеет функцию addObject и getGameObjectsAt. Тогда я мог бы передать мой WorldSomething объект функции GameObject обновления:

class World { 
    public: 
     void update(); 
    private: 
     std::vector<GameObject*> gameObjects 
} 



class WorldSomething { 
    public: 
     void addObject(GameObject* obj); 
     std::vector<GameObject const*> getGameObjectsAt(float x,float y,float  radius) const; 
    private: 
     World* world; 
} 

class GameObject { 
    public: 
    void update(const WorldSomething& worldSomething); 
} 

Однако это перемещает свои операции дальше от моих данных, и я должен передать свой объект WorldSomething к функции обновлени GameObject. Есть ли лучшее решение? (Я использую C++, если это помогает ...) И что бы вы назвали таким классом WorldSomething?

Answer 1

Однако это перемещает свои операции дальше от моих данных ...

Это на самом деле желаемого.

---

Использование интерфейсов в 1-ом месте разъединить логики и данных:

struct IWorldAdd { 
    virtual void addObject(GameObject* obj) = 0; 
    virtual std::vector<GameObject const*> getGameObjectsAt(float x,float y,float radius) 
     const = 0; 
    virtual ~IWorldAdd() {}; 
}; 

---

class World : public IWorldAdd{ 
public: 
    void update(); 
    void addObject(GameObject* obj); 
    std::vector<IGameObject const*> getGameObjectsAt(float x,float y,float radius) const; 
private: 
     std::vector<GameObject*> gameObjects 
}; 

---

struct IGameObject { 
    virtual void update() = 0; 
    virtual Point getCenterPosition() = 0; 
    virtual ~IGameObject() {} 
}; 

---

Добавить стратегию, которая обеспечивает логику

template<class UpdateStrategy> 
class GameObject : public IGameObject { 
public: 
    GameObject(UpdateStrategy* strategy) : strategy_(strategy) 
    void update() { 
     // Do stuff needed to update the things directly related to the 
     // GameObject's rendering and such 

     // Call the strategy needed to update a particular game object 
     // in Relation to other objects nearby 
     strategy_->updateRestOfWorld(); 
    } 
private: 
    UpdateStrategy* strategy_; 
}; 

---

class AConcreteUpdateStrategy { 
    AConcreteUpdateStrategy(IWorldAdd* world) : world_(world) { 
    } 

    void updateRestOfWorld(const IGameObject* gameObject) { 
     Point centerPoint gameObject->getCenterPosition(); 
     std::vector<const IGameObject*> otherGameObjects = 
      world_->getGameObjectsAt(centerPoint.x, centerPoint.x, 500); 
     // Inspect if there are specific game objects nearby 
     if(gameObjectIsNearBy) { 
       world->addObject(new OtherGameObject()); 
     } 
    } 
private: 
    IWorldAdd* world_; 
}; 

Это грубый набросок, надеюсь, вы получите идею.

Answer 2

Кажется, что ваш класс отвечает за два разных аспектов. Вы видите, когда вы думаете, что часть вашего кода должна использовать только «половину» вашего класса World; то может быть, ваш Мир слишком большой?

Другими словами: было бы разумно придумать класс HalfOfTheWorld, который содержит те функции, которые нужны игровым объектам ?!

И тогда у вас может быть AnotherHalfOftheWorld, доставляющий другие аспекты; и при необходимости; ваш класс World может затем содержать один член каждого из этих новых классов.

Answer 3

Есть ли лучшее решение?

Я думаю, что лучше оставить классы как есть.

Я не вижу никакого преимущества для добавления другого слоя (или более слоев), чтобы предотвратить GameObject от возможности позвонить World::update().

Дисциплина программиста - это решение. Убедитесь, что ваш поток исполнения хорошо понятен вашим разработчикам. World::update() не будет вызываться от GameObject, если поток выполнения не требует его.