Obiekty Gry Rozmawiają Ze Sobą

Ogólne rozwiązania komunikacji między obiektami unikające ciasnego sprzężenia:

1. Wzór mediatora
2. Obserwator wzór

Prawdopodobnie dotyczy to nie tylko klas gry, ale także klas w ogólnym znaczeniu. wzorzec MVC (model-view-controller) wraz z sugerowaną pompą komunikatów to wszystko, czego potrzebujesz.

"Enemy " I" Player " prawdopodobnie pasują do modelowej części MVC, nie ma to większego znaczenia, ale zasada jest taka, że wszystkie modele i widoki oddziałują za pośrednictwem kontrolera. Tak więc, powinieneś zachować referencje (lepsze niż wskaźniki) do (prawie) wszystkich innych instancji klasy z tego 'kontrolera' klaso, nazwijmy to kontrolerem. Dodaj do niego pompę komunikatów (różni się w zależności od platformy, dla której kodujesz), najpierw Utwórz instancję (przed jakąkolwiek inną klasą, A inne obiekty będą jej częścią) lub na koniec (a inne obiekty będą przechowywane jako odniesienia w ControlDispatcher).

Oczywiście Klasa ControlDispatcher prawdopodobnie będzie musiała zostać podzielona dalej na bardziej wyspecjalizowane Kontrolery tylko po to, aby utrzymać kod na pliku w okolicach 700-800 linii (jest to limit dla mnie przynajmniej) i może nawet mieć więcej wątków pompowania i przetwarzania wiadomości w zależności od potrzeb.

Cheers

Oto zgrabny system zdarzeń napisany dla C++11, którego możesz użyć. Używa szablonów i inteligentnych wskaźników, a także Lambda dla delegatów. Jest bardzo elastyczny. Poniżej znajduje się również przykład. Napisz do mnie na [email protected] jeśli masz pytania na ten temat.

To, co te klasy dają, to sposób wysyłania zdarzeń z dołączonymi do nich dowolnymi danymi oraz łatwy sposób bezpośredniego wiązania funkcji, które akceptują już przekonwertowane typy argumentów, które System rzuca i sprawdza pod kątem poprawności konwersja przed wywołaniem delegata.

Zasadniczo każde zdarzenie pochodzi z klasy IEventData(możesz ją nazwać IEvent, jeśli chcesz). Każda" ramka " wywołana przez ProcessEvents (), w którym to momencie System zdarzeń zapętla wszystkie delegaty i wywołuje delegaty dostarczone przez inne systemy, które subskrybowały każdy typ zdarzenia. Każdy może wybrać, które wydarzenia chcą subskrybować, ponieważ każdy typ Wydarzenia ma unikalny identyfikator. Możesz również użyć lambda, aby zapisać się do zdarzenia takie jak: AddListener (MyEvent:: ID (), [&] (shared_ptr ev){ rób swoje..

W każdym razie, oto klasa z całą implementacją:

#pragma once

#include <list>
#include <memory>
#include <map>
#include <vector>
#include <functional>

class IEventData {
public:
    typedef size_t id_t; 
    virtual id_t GetID() = 0; 
}; 

typedef std::shared_ptr<IEventData> IEventDataPtr; 
typedef std::function<void(IEventDataPtr&)> EventDelegate; 

class IEventManager {
public:
    virtual bool AddListener(IEventData::id_t id, EventDelegate proc) = 0;
    virtual bool RemoveListener(IEventData::id_t id, EventDelegate proc) = 0; 
    virtual void QueueEvent(IEventDataPtr ev) = 0; 
    virtual void ProcessEvents() = 0; 
}; 


#define DECLARE_EVENT(type) \
    static IEventData::id_t ID(){ \
        return reinterpret_cast<IEventData::id_t>(&ID); \
    } \
    IEventData::id_t GetID() override { \
        return ID(); \
    }\

class EventManager : public IEventManager {
public:
    typedef std::list<EventDelegate> EventDelegateList; 

    ~EventManager(){
    } 
    //! Adds a listener to the event. The listener should invalidate itself when it needs to be removed. 
    virtual bool AddListener(IEventData::id_t id, EventDelegate proc) override; 

    //! Removes the specified delegate from the list
    virtual bool RemoveListener(IEventData::id_t id, EventDelegate proc) override; 

    //! Queues an event to be processed during the next update
    virtual void QueueEvent(IEventDataPtr ev) override; 

    //! Processes all events
    virtual void ProcessEvents() override; 
private:
    std::list<std::shared_ptr<IEventData>> mEventQueue; 
    std::map<IEventData::id_t, EventDelegateList> mEventListeners; 

}; 

//! Helper class that automatically handles removal of individual event listeners registered using OnEvent() member function upon destruction of an object derived from this class. 
class EventListener {
public:
    //! Template function that also converts the event into the right data type before calling the event listener. 
    template<class T>
    bool OnEvent(std::function<void(std::shared_ptr<T>)> proc){
        return OnEvent(T::ID(), [&, proc](IEventDataPtr data){
            auto ev = std::dynamic_pointer_cast<T>(data); 
            if(ev) proc(ev); 
        }); 
    }
protected:
    typedef std::pair<IEventData::id_t, EventDelegate> _EvPair; 
    EventListener(std::weak_ptr<IEventManager> mgr):_els_mEventManager(mgr){

    }
    virtual ~EventListener(){
        if(_els_mEventManager.expired()) return; 
        auto em = _els_mEventManager.lock(); 
        for(auto i : _els_mLocalEvents){
            em->RemoveListener(i.first, i.second); 
        }
    }

    bool OnEvent(IEventData::id_t id, EventDelegate proc){
        if(_els_mEventManager.expired()) return false; 
        auto em = _els_mEventManager.lock(); 
        if(em->AddListener(id, proc)){
            _els_mLocalEvents.push_back(_EvPair(id, proc)); 
        }
    }
private:
    std::weak_ptr<IEventManager> _els_mEventManager; 
    std::vector<_EvPair>        _els_mLocalEvents; 
    //std::vector<_DynEvPair> mDynamicLocalEvents; 
}; 

Oraz plik Cpp:

#include "Events.hpp"

using namespace std; 

bool EventManager::AddListener(IEventData::id_t id, EventDelegate proc){
    auto i = mEventListeners.find(id); 
    if(i == mEventListeners.end()){
        mEventListeners[id] = list<EventDelegate>(); 
    }
    auto &list = mEventListeners[id]; 
    for(auto i = list.begin(); i != list.end(); i++){
        EventDelegate &func = *i; 
        if(func.target<EventDelegate>() == proc.target<EventDelegate>()) 
            return false; 
    }
    list.push_back(proc); 
}

bool EventManager::RemoveListener(IEventData::id_t id, EventDelegate proc){
    auto j = mEventListeners.find(id); 
    if(j == mEventListeners.end()) return false; 
    auto &list = j->second; 
    for(auto i = list.begin(); i != list.end(); ++i){
        EventDelegate &func = *i; 
        if(func.target<EventDelegate>() == proc.target<EventDelegate>()) {
            list.erase(i); 
            return true; 
        }
    }
    return false; 
}

void EventManager::QueueEvent(IEventDataPtr ev) {
    mEventQueue.push_back(ev); 
}

void EventManager::ProcessEvents(){
    size_t count = mEventQueue.size(); 
    for(auto it = mEventQueue.begin(); it != mEventQueue.end(); ++it){
        printf("Processing event..\n"); 
        if(!count) break; 
        auto &i = *it; 
        auto listeners = mEventListeners.find(i->GetID()); 
        if(listeners != mEventListeners.end()){
            // Call listeners
            for(auto l : listeners->second){
                l(i); 
            }
        }
        // remove event
        it = mEventQueue.erase(it); 
        count--; 
    }
}

Używam klasy EventListener dla wygody jako klasy bazowej dla każdej klasy, która chciałaby słuchać wydarzeń. Jeśli korzystasz z tej klasy słuchania i dostarczasz ją do swojego event managera, możesz skorzystać z bardzo wygodnej funkcji OnEvent(..), aby zarejestrować swoje wydarzenia. A klasa bazowa automatycznie anuluje subskrypcję klasy pochodnej ze wszystkich zdarzeń, gdy zostanie zniszczona. Jest to bardzo wygodne, ponieważ zapomnienie o usunięciu delegata z menedżera zdarzeń, gdy klasa zostanie zniszczona, prawie na pewno spowoduje awarię programu.

Zgrabny sposób na uzyskanie unikalnego identyfikatora typu dla zdarzenia poprzez zwyczajne zadeklarowanie statycznej funkcji w klasie, a następnie wrzucenie jej adresu do int. Ponieważ każda klasa będzie miała tę metodę pod różnymi adresami, może być służy do unikalnej identyfikacji zdarzeń klasowych. Możesz również dodać typename () do int, aby uzyskać unikalne id, jeśli chcesz. Można to zrobić na różne sposoby.

Oto przykład jak tego użyć:

#include <functional>
#include <memory>
#include <stdio.h>
#include <list>
#include <map>

#include "Events.hpp"
#include "Events.cpp"

using namespace std; 

class DisplayTextEvent : public IEventData {
public:
    DECLARE_EVENT(DisplayTextEvent); 

    DisplayTextEvent(const string &text){
        mStr = text; 
    }
    ~DisplayTextEvent(){
        printf("Deleted event data\n"); 
    }
    const string &GetText(){
        return mStr; 
    }
private:
    string mStr; 
}; 

class Emitter { 
public:
    Emitter(shared_ptr<IEventManager> em){
        mEmgr = em; 
    }
    void EmitEvent(){
        mEmgr->QueueEvent(shared_ptr<IEventData>(
            new DisplayTextEvent("Hello World!"))); 
    }
private:
    shared_ptr<IEventManager> mEmgr; 
}; 

class Receiver : public EventListener{
public:
    Receiver(shared_ptr<IEventManager> em) : EventListener(em){
        mEmgr = em; 

        OnEvent<DisplayTextEvent>([&](shared_ptr<DisplayTextEvent> data){
            printf("It's working: %s\n", data->GetText().c_str()); 
        }); 
    }
    ~Receiver(){
        mEmgr->RemoveListener(DisplayTextEvent::ID(), std::bind(&Receiver::OnExampleEvent, this, placeholders::_1)); 
    }
    void OnExampleEvent(IEventDataPtr &data){
        auto ev = dynamic_pointer_cast<DisplayTextEvent>(data); 
        if(!ev) return; 
        printf("Received event: %s\n", ev->GetText().c_str()); 
    }
private:
    shared_ptr<IEventManager> mEmgr; 
}; 

int main(){
    auto emgr = shared_ptr<IEventManager>(new EventManager()); 


    Emitter emit(emgr); 
    {
        Receiver receive(emgr); 

        emit.EmitEvent(); 
        emgr->ProcessEvents(); 
    }
    emit.EmitEvent(); 
    emgr->ProcessEvents(); 
    emgr = 0; 

    return 0; 
}

Bądź ostrożny z "systemem stylu wiadomości", prawdopodobnie zależy to od implementacji, ale zazwyczaj tracisz statyczne sprawdzanie typu, a następnie możesz bardzo utrudnić debugowanie niektórych błędów. Zauważ, że wywołanie metod obiektu jest już systemem podobnym do wiadomości.

Prawdopodobnie po prostu brakuje ci pewnych poziomów abstrakcji, na przykład do nawigacji gracz mógłby użyć nawigatora zamiast wiedzieć wszystko o samej mapie. Mówisz też, że this has usually descended into setting lots of pointers, co to za wskaźniki? Prawdopodobnie dajesz im złą abstrakcję?.. Bezpośrednie poznawanie obiektów o innych, bez przechodzenia przez interfejsy i półprodukty, jest prostą drogą do uzyskania ściśle powiązanego projektu.

Wiadomości to zdecydowanie świetny sposób, ale systemy wiadomości mogą mieć wiele różnic. Jeśli chcesz, aby Twoje klasy były ładne i czyste, napisz je, aby były nieświadome systemu wiadomości i zamiast tego niech przyjmują zależności od czegoś prostego, takiego jak "ILocationService", które mogą być zaimplementowane w celu publikowania/żądania informacji od rzeczy takich jak Klasa Map. Podczas gdy skończysz z większą liczbą klas, będą one małe, proste i zachęcają do czystego projektowania.

Wiadomości to chodzi o coś więcej niż tylko odsprzęganie, ale także o bardziej asynchroniczną, współbieżną i reaktywną architekturę. Wzorce integracji przedsiębiorstw Gregor Hophe to świetna książka, która opowiada o dobrych wzorcach przesyłania wiadomości. Erlang OTP czy Scala implementacja wzorca aktora dostarczyły mi wielu wskazówek.

@ kellogs sugestia MVC jest poprawna i używana w kilku grach, choć jej dużo jest bardziej powszechna w aplikacjach internetowych i frameworkach. To może być przesada i za dużo na to.

Przemyślałbym Twój projekt, dlaczego gracz musi rozmawiać z wrogami? Czy oboje nie mogli dziedziczyć po klasie aktorskiej? Dlaczego aktorzy muszą rozmawiać z mapą?

Jak czytam to co napisałem to zaczyna pasować do frameworka MVC...Najwyraźniej ostatnio wykonałem zbyt dużo pracy z railami. Jednak byłbym chętni do postawienia, muszą tylko wiedzieć rzeczy, takie jak, zderzają się z innym aktorem, i mają pozycję, która powinna być w stosunku do mapy tak czy inaczej.

Oto implementacja Planetoid {[10] } nad którą pracowałem. Twoja gra może być i prawdopodobnie jest złożona.