Moin epvp,
ich wurde durch den Singleton-Thread (
) darauf aufmerksam gemacht, dass mein aktueller Code nicht sonderlich schön aufgeteilt ist. Außerdem ist es mit einem Wunsch zusammengefallen, meine Applikation wirklich Multiuserfähig zu machen...
Ich zeig euch einfach Code, das kann ich besser als Deutsch..
ACHTUNG, ALLES PSEUDOCODE ZUM VERDEUTLICHEN
So war es bisher:
Code:
class Inventory : public Singleton<Inventory>
{
public:
void SetItemData(ItemData&);
void GetItemData(ItemData&);
};
class Network : public Singleton<Network>
{
public:
void MainLoop()
{
if( (recvd = recv(&buf)) > 0)
{
PacketHandler::Instance()->OnRecvPackets(&buf, recvd);
}
};
class PacketHandler : public Singleton<PacketHandler>
{
public:
void OnRecvPacket(uint8_t* data, size_t len)
{
buf_queue.insert(buf_queue.end(), data, data + len);
MainPacketHandler();
}
void MainPacketHandler()
{
uint8_t packet_id = ((uint8_t*)&buf_queue[0])[0];
switch(packet_id)
{
case ITEM_ADD:
Inventory::Instance()->SetItemData(...);
buf_queue.erase(buf_queue.begin(), sizeof(ItemAddPacket));
};
}
private:
std::vector<uint8_t> buf_queue;
};
Dass das Schwachsinn ist, ist mir irgendwie jetzt auch klar...
Darum dachte ich, ich könnte eine einzige Klasse machen, die so aussieht:
Code:
class Main
{
private:
Inventory m_inventory;
Network m_network;
PacketHandler m_handler;
};
Jetzt habe ich aber das Problem, dass die einzelnen Klassen nach wie vor aufeinander Zugreifen müssen.
Hier kommt meine Frage:
Soll ich lieber jeder einzelnen Klassen Referenzen auf die benötigten geben, so:
(Am Beispiel der Netzwerk-Klasse)
Code:
class Network : public Singleton<Network>
{
public:
Network(Main* inst, PacketHandler* handler)
{
m_client_instance = inst;
m_packet_handler = handler;
}
void MainLoop()
{
if( (recvd = recv(&buf)) > 0)
{
m_packet_handler->OnRecvPackets(&buf, recvd);
}
private:
Main* m_client_instance;
PacketHandler* m_packet_handler;
};
Oder lieber in der Main-Klasse alle "Durchsatzfunktionen" neu definieren, also so:
Code:
class Network : public Singleton<Network>
{
public:
Network(Main* inst)
{
m_client_instance = inst;
}
void MainLoop()
{
if( (recvd = recv(&buf)) > 0)
{
m_client_instance->OnRecvPackets(&buf, recvd);
}
private:
Main* m_client_instance;
};
class Main
{
public:
void OnRecvPacket(uint8_t* data, size_t len)
{
m_handler.OnRecvPackets(data, len);
}
private:
Inventory m_inventory;
Network m_network;
PacketHandler m_handler;
};
Ooooder die Main-Klasse von allen anderen erben lassen (was ich aber für die schlechteste Alternative halte)
Oder aber ist alles Bullshit und die wahre Lösung ist ganz anders?
Wäre nett, wenn jemand das versteht und helfen kann
Fehler/Ungereimtheiten im Code könnten sein, ich hab das grade nur aus'm Kopf auf das wesentliche reduziert geschrieben.. Einfach nachfragen und/oder drauf aufmerksam machen.
epvp, do your thing!
€: Ich probier grade rum und muss sagen: das mit Vererbung wirkt gar nicht SOO doof. Meinungen?
Padmak
