spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

class DatenElement //von dieser Klasse sollen später alle Klassen erben, die übers Netz geschickt werden sollen.

{
    DWORD ID;
        CRITICAL_SECTION Critic;
    Anbindung* DatenAnbindung; 

        size_t Size;
        char* Data;
        unsigned short Version;

    virtual void PerformNetAction() = 0; //hier werden die Daten beim Server serialisiert und beim Client deserialisiert 


    void SetDatas(size_t s, char* datas); //nutzt die CRITICAL_SECTION um die Daten sicher in den Buffer der Klasse zu kopieren. Auch erhöht die Methode, die Version um 1

    size_t GetDatas(char*& datas); //hier wird der Buffer der Klasse in den Pointer kopiert.

}:

class Anbindung //hier registieren sich alle DatenElemente und bekommen eine eindeutige ID.

{
    SecureMap<DWORD, DatenElement*> Elemente;   //eine threadsichere Version von std::map

};

class MemExServerClient : public BasicServerClient //hier werden die Clientdaten gespeichert von den Clients die beim Server angemeldet sind 

{
    CRITICAL_SECTION Critic;

    SecureList<MemExServer_Thread_Client*> Thread_Client_List;

    void PassNetMsg(const Paket&); //Diese Methode ermöglicht es, empfangene Pakete an die Thread_Clients weiter zu vermitteln

        
    virtual void UpdateClient(void); //Sammelt die Daten von den ThreadClient Instanzen, pakkt das ein großes Paket und schickt dieses ab.


    void RegistrateMemExServer_Thread_Client(MemExServer_Thread_Client*); //hiermit können sich die Thread_Clients in die SecureList eintragen

};

class MemExServer : public BasicServer, public Anbindung
{
     friend void MemExServerClient::UpdateClient(void);
public:
    void RegistateElement(DatenElement* e, DWORD id);
};


class MemExServerThread //Von dieser Klasse sollten die Klassen abgeleitet werden, die einen eigenen Thread haben 

{
    SecureList<MemExServer_Thread_Client*> Thread_Client_List;

    void UpdateAllThreadClients(void); //Diese Methode wird vom Thread aus aufgerufen und updatet alle DatenElemente, die zum Thread gehören

    void RegistrateMemExServer_Thread_Client(MemExServer_Thread_Client*); //hiermit können sich die Thread_Clients in die SecureList eintragen

};


class MemExServer_Thread_Client //Verbindungsklasse zwischen den Threads und den Clients. Ermöglicht den Austausch der Listen(von Thread zum Client) und der Pakete (vom Client zum Thread)

{       
    struct CompareContainer
    {
        DatenElement*   Element;
        unsigned short  Version;

        inline bool operator < (const CompareContainer& c)      { return Element < c.Element; }
        inline operator DatenElement* (void)                    { return Element; }
    };

    struct UpdateContainer
    {
        DWORD ElementID;
        bool Update;

        inline bool operator == (const UpdateContainer& c)      { return ElementID == c.ElementID; }
        inline bool operator < (const UpdateContainer& c)       { return ElementID < c.ElementID; }
    };

    std::list<CompareContainer> OwnElements;
    SecureList<UpdateContainer> UpdateElements;
    
    void CheckDelete(void)              { if(Client == 0 && Thread == 0) delete this; }
    
    virtual void CreateCompareList(std::list<DatenElement*>&) = 0; //wird nur vom Thread aus aufgerufen

    virtual void ProcessNetMsg(const Paket&) = 0; //wird nur vom Client(Empfangsthread) aus aufgerufen


    inline void AddUpdateElements(std::list<UpdateContainer> &list)     {   std::list<UpdateContainer>::iterator it = UpdateElements.lockbegin(); list.insert(list.begin(), it, UpdateElements.end()); 
                                                                            UpdateElements.clear(); UpdateElements.unlock(); }

    MemExServerClient* Client;
    MemExServerThread* Thread;
    bool DeleteIt;


    MemExServer_Thread_Client(MemExServerClient* c, MemExServerThread* t) : DeleteIt(false) { t->RegistrateMemExServer_Thread_Client(this); c->RegistrateMemExServer_Thread_Client(this); }
};