ich möchte ein Multiplayer-Spiel schreiben. Es müssen verschiedene Arten von Daten ausgetauscht werden: Spieler-Positionen, Abfeuern von Raketen, etc. (könnte man enummerieren).

Nun habe ich verschiedene Möglichkeiten:

1.) Ich schreibe eine Klasse, die einen großen char-Buffer enthält. Wenn ich Daten verschicken will sagt das erste Byte des Buffers, wie die restlichen Bytes zu interpretieren sind. Das Herüberkopieren könnte man mit casts oder memcpy() realisieren. Das ganz ist aber durch das Kopieren ein bischen langsamer, außerdem nicht ganz Typsicher und sieht zudem blöd aus. Und das ganze memcpy()-Geschreibe wird auch ziemlich nervtötend...

2.) Ich habe eine struct für ein Paket:

struct packet
{
    int type;
    union ...
} __ attribute__((packet));

Ist im alten C-Style... das empfangen ginge dann in etwa so:

Packet p;
send(&p,/*...*/);

Also recht komfortabel

3.) Kann man so etwas auch mit Klassen machen? Z.B. so?

class PacketBase
{
    virtual void get_type() = 0;
};

class PositionPacket : public PacketBase
{
    virtual void get_type() { return POSITION_PACKET; }
    vector Position;
};

PositionPacket p;
send(&p,/* ... */);

Das Problem ist ja, wenn ich direkt aus der Klasse lese (kann eine Klasse das Attribut packed haben?), können da ja immer noch Daten drin sein, die ich vllt gar nicht senden will (die virtual pointer table und wer weiß was)...

Welche Möglichkeit ist am ehesten ratsam/realisierbar? Gibt es andere gute Möglichkeiten?

Gruß,
voidpointer

So weit ich weiß, wird das auch (immer ?) so gemacht...

POSPL x y -END- //POSitionen d. Spielers (PLayer)
FIRER x_from y_from x_to y_to zeit -END- //Abfeuern (FIRE) von Raketen (Rocket)

hätte den Nachteil, dass du die ints etc immer erst in strings, dann gibts aber auch noch so ne Möglichkeit:

POSPL 10 //länge des Datenblocks
{binärdaten, genau 10 Byte}
x,
y

alternativ kannst du statt den Strings am Anfang auch deine Nummer nehmen, aber das wird irgendwann vll doch ein wenig unübersichtlich...

Ich würd halt Klassen für das jeweilige Ereignis machen und dann das Empfangen mithilfe eines Vectors machen, bsp.:

class Tnetwork_base
{
public:
virtual ~Tnetwork_base ();
// vll << und >> als virtual deklarieren und die dann zum basteln und auslesen der Klasse nehmen, wenn sie empfangen wird... kA
};

class Trocket : Tnetwork_base
{
//...
};

std::vector <Tnetwork_base *> recv_data;

typedef char byte; //kannst auch char nehmen - die meisten compiler kennen ja auch byte...

void OnRecv (byte *recv_bytes)
{
 const size_t L (static_cast <size_t> (strlen (recv_bytes)));
 if ((L > 5) && (!_mbsncmp (recv_bytes, "FIRER", 5))
  {
   //klasse aus den daten aufbauen und in den vector hauen;
  }
 else if (/*next*/)
{/*usw*/}
}

Das Senden hierzu würde analog gehen - also in etwa so:

std::vector <Tnetwork_base *> send_data;

void OnFireRocket (size_t dmg, const TPoint &where_from, const TPoint &where_to)
{
send_data.push_back (new Trocket (/*wie au immer*/) );
}

und dann kannste ja nen send-template bauen:

template <class T>
bool /*successful*/ send_data (const T &value) throw (...)
{
throw std::bad_typeid ("noch nicht gebaut...");
}

template < >
bool send_data <Trocket> (const Trocket &value)
{
std::string tosend;
value >> tosend;
send /*API-fkt*/ (tosend.c_str ());
}

wobei mir gerade einfällt: std::deque wär wohl besser gewesen ^^ außerdem solltest du vll noch ne Wrapper funktion fürs push_back schreiben, damit irgendwo nen event ausgelöst wird, damit du nicht aller x sekunden gucken musst, ob was in der que (des vectors o.ä.) ist...

Hier hast du zwar auch immer x umwandlungen dabei aber ich denke, es sollte sich trotzdem nicht soo sehr bemerkbar machen und ist übersichtlich...

Also ich würds so machen, aber ist auch nur nen Vorschlag...

Und davon würd ich dir auf jeden Fall abraten:

struct packet
{
    int type;
    union ...
} __ attribute__((packet));

Mal davon abgesehen, dass es mit Sicherheit sehr fehleranfällig ist: Überleg mal, wie groß (vll nicht unbedingt vom speicher, weil da kann man ja ptr nehmen aber vom Code her) das ganze wird, wenn du genügend Dinge einbaust, chat, 7 versch. raketentypen und 12 versch. abfeuerungsarten, einheiten, rohstoffe, chat, bilder, ...
Glaube nicht, dass du dann noch durchsiehst - abgesehen davon würd ich unions nur nehmen, wenn man sie unbedingt braucht - und das ist in meinen Augen nen klasse Bsp für templates...

bb - und ich hoffe, ich hab deine Frage wenigstens ansatzweise verstanden ^^

Was ist denn so schlimm daran,eine Struct/Class mit den nötigen informationen zu versenden?
Ich finde das ist wesentlich einfacher als einen string zu senden,der dann vom client erstmal geparst werden muss etc.

spätestens mit dem ersten dynamischen speicher geht das nicht mehr. mit der methode des OPs ist man im grunde auf PODs beschränkt.

und im schlimmsten fall funktioniert nicht einmal das verschicken eines floats/doubles.

Und änder mal deine Signatur, "static_cast<static void*>" is Blödsinn

Was ist denn so schlimm daran,eine Struct/Class mit den nötigen informationen zu versenden?
Ich finde das ist wesentlich einfacher als einen string zu senden,der dann vom client erstmal geparst werden muss etc.

Guck Dir auch mal das hier an:
Endianess