ich habe ein Problem:
Ich möchte gerne eine Art Proxy schreiben der sich zwischen Client und Server (Gameserver und Gameclient) schaltet und die einzelnen UDP Pakete mit deren Inhalt anzeigt (mitsnifft).
Den Proxy hab ich hingekriegt, aber das Anzeigen des Inhaltes der einzelnen Pakete macht mir immernoch Probleme. Kurze Infos zum Protokoll: Die ersten 2 Bytes sind nicht relevant, das dritte ist die Art des Inhalts (Positionsupdates, geschossen, etc. Ich werde es hier nun Status nennen). Danach folgen die Inhalte (Wer hat geschossen, etc.).
Nun gibt es verschiedene Status Arten. Ich möchte nun für jedes Paket sehen, z.B. wer hat geschossen, etc, aber alle Pakete sind ja verschieden. Dies ist meine aktuelle Version um den Clienten auszulesen:

switch(status)
{
case 1:
  printf("[CLIENT]BlaBla\n");
  printf("\t Blabla: %u\n",ReadBla(buffer[3], buffer[4]));
  break;
default:
  printf("[CLIENT]UNKNOWN\n");
}

Dies wird nach ca. 15 Paketen schon unübersichtlich, (Es gibt ca. 120),
deshalb wollte ich so garnicht weitermachen. Ich hab gehört sowas kann man Objektorientiert machen?
Da komme ich auch gleich zu meine nächsten Frage, nämlich: So ein Paket besteht nun z.B. aus Spieler-ID und Spielername. Das Paket ist nun z.B. so:

0x56 (Status)
0x05 (Spieler-ID)
0x06 (Länge von dem Spielernamen)
6 Bytes Spielername (Für jeden Buchstaben ein Byte bzw. Char)

Um diese Art von 'String' auszulesen habe ich mir nun eine Funktion gebaut:

char* ReadString(char *buffer, int position)
{
	unsigned short anzahl = (unsigned short)buffer[position];
	char *string = (char*)malloc(anzahl);
	strncpy(string, buffer+position+1, anzahl);
	string[anzahl] = '\0';
	return string;
}

char *servername = ReadString(buffer, position);
position = position + sizeof(servername) + 2;

char *mapname = ReadString(buffer, position);
position = position + sizeof(mapname) + 2;

Nun wird es bei mehreren String hintereinander unübersichtlich, da ich immer die Position mitzählen muss.
Ich glaube sowas kann man auch Objektorientiert machen? Oder kann ich so irgendwie einen neuen Datentyp entwickeln? Mit struct hatte ich schon rumgespielt.

Unübersichtlichkeit wenn mehrere Pakete eingetragen sind
Diese komischen Strings möglichst einfach auslesen können

Ich habe in C programmiert bis ich gesehen hatte, dass man das auch mit OOP lösen kann.
Ab da an bin ich auf C++ umgestiegen (Bin nur deshalb). Bitte nicht schlagen bei printf und co.

Vielen Vielen Dank im Voraus,

Gruß Jermuk

Ich hab gehört sowas kann man Objektorientiert machen?

Man kann fast alles objektorientiert lösen. Wenn du es gehört hast, kannst du doch da auch mal nachfragen?
(BTW.: Stört dich so ein Fragezeichen statt einem Punkt am Ende einer Aussage überhaupt nicht?)

Damit du nicht ganz ohne etwas in der Hand da stehst:
Factory + std::map + Polymorphie
std::string

EDIT: Man kann auch Fragezeichen anstatt Punkte setzten. Dann soll es eine Art Frage sein. Und leider ist von dem ich das gehört habe momentan nicht zu erreichen. O

Es waren zwei Lösungsansätze zu deinen beiden Fragen.
Du "bastelst" dir eine Klassenhierarchie mit entsprechenden virtuellen Funktionen. Für jede Klasse eine Factory, die ein entsprechendes Objekt erzeugt und zurückliefert. Damit das funktioniert, brauchst du Zeiger. Du hast ursprünglich einen int in deinem switch verwendet, jetzt registrierst du in einer std::map pro int die zugehörige Factory.
std::string ist immer bequemer als rohe strings. Wenn du C++ nicht nur wegen dem "class" verwendest, solltest du zur Erleichterung bei Zeichenketten zu std::string greifen. Überhaupt solltest du dich an der STL bedienen.

Könntest du oder irgendwer anderes zum Punkt 1 noch etwas erläutern? Da ich nocht nicht so viel OOP gemacht habe, kannte ich die Factory Methode nicht.
Ich habe ein gutes und verständliches Beispiel auf Wikipedia gefunden und habe es auch hoffentlich verstanden. Habe mir auch einige Tutorials dazu gefunden,
aber ich kann die Factory Methode nicht auf mein Problem beziehen.
Es gibt ein Produkt, ein konkretes Produkt, einen Erzeuger und einen konkreten Erzeuger, soviel habe ich schon verstanden.
Sind jetzt die konkreten Erzeuger die verschiedenen Statuse (wie schreibt man es richtig?) und die Produkte z.B. die SessionID?
D.h. ich bräuchte eine Klasse namens PlayerID (oder weitere für z.B. Positionsangaben, SessionID) in der die ID aus dem String herausgelsen wird (konkretes Produkt??) und eine weitere namens Status_1 in der alles zusammen gesetzt wird (Erzeuger).
Aber wozu dann die konkreten Erzeuger oder allgemeinen Produkte?
Die Polimorphie habe ich (hoffentlich) einigermaßen verstanden. Aber ich weiß leider nicht,
was ich nun in welche Klasse zun soll oder was als Virtuell gekennzeichnet werden soll.
Vielen vielen Dank für deine Antwort!

Und nochmal vielen Dank an alle die mir helfen können!

Gruß Jermuk

In beiden Fällen besteht aber die Möglichkeit die Protokoll-Umwandlung generisch zu betreiben.
Das ist auf jeden Fall praktischer als für jedes potentielle Objekt im Netzwerk-Strom eine Klasse/Struct zu definieren.
Dafür braucht man eine Definition von Regeln, beispielsweise als XML, die definiert was bei einem bestimmten Token/Code passieren soll.
Die Auswertung des Protokoll-Streams passiert dann automatisiert anhand deiner Regeldefinition.

Vielen Dank für deine Antwort,

Gruß Jermuk

// item.hpp
// Basisklasse für alle Pakete (oder was weiß ich)
class Item
{
public:
    virtual ~Item(){}
};

// factory.hpp
#include <map>

class Item;
class Factory
{
public:
    typedef int ID;
    typedef Item* (*CreateFunc)();
    typedef std::map<ID, CreateFunc> AMap;

    Item* Create(ID id)
    {
        AMap::const_iterator it = Assocs_.find(id);
        if (it == Assocs_.end())
            // handle.. throw, o.ä...
        return it->second();
    }

    bool Register(ID id, CreateFunc f)
    {
        AMap::iterator it = Assocs_.lower_bound(id);
        if (it != Assocs_.end() && it->first == id)
            it->second = f;
        else
            Assocs_.insert(std::make_pair(id,f));
        return true;
    }

    static Factory& Instance()
    {
        static Factory F;
        return F;
    }

private:
    Factory(){}
    Factory(Factory&);
    void operator=(Factory&);

    AMap Assocs_;
};

// concrete.hpp
// konkretes Paket
#include "item.hpp"

class Concrete : public Item
{
// ...
};

// concrete.cpp
#include "concrete.hpp"
#include "factory.hpp"

Item* CreateConcrete()
{
    return new Concrete;
}
bool Dummerich = Factory::Instance().Register(1, CreateConcrete);

Eine Concrete Instanz erstellt man nun mit der ID 1.
Die Fabrik ist hier als Singleton implementiert. Beim Singleton selber könnte man sich noch mehr Mühe geben, wenn man die Fabrik so verwenden möchte. Wenn man sie als 'normales' Objekt benutzt, muss der Besitzer die Registrierung initiieren. Die ganze Fabrik kann man auch sehr schön komplett generisch aufbauen.

Ob es in Deinem Fall überhaupt Sinn macht 120 konkrete Pakete zu definieren, kann ich nicht beurteilen.

Gruß Jermuk

Klingt für mich etwas einfacherer als OOP.

Ich denke dir geht noch einiges an Grundwissen ab. Auch so ein Vorgehen wie nurf es vorschlägt kannst du wunderbar mit objektorientierten Techniken umsetzen.
Ich denke du solltest erstmal mit C++ anfangen, denn nur vom Hörensagen, dass das mit OOP geht wird deine Lösung nicht besser... OOP ist kein Kurzbegriff für Ploymorphie und Factories

Ich meine sowieso, dass der Versuch weg von C hin zu einer komplexen Lösung in C++ eher Bloat verursacht, als dass es hilft. Der einzige Vorteil wird sein, dass du von dem Monster-switch in deiner main wegkommst, und die Fallunterscheidungen auslagerst - in eigene Klassen, in ein XML, usw. Es wird übersichtlicher, aber die Gefahr, dass du irgendwann nicht mehr durchblickst ist auch recht hoch. Es kommt sicher eine schönere Lösung raus, keine Frage! Aber du solltest das halt auch verstehen.

Du könntest das wohl auch mit einem Script lösen. Speicher einfach den ganzen aufgefangenen Strom roh in einer Textdatei, bisschen regexp auf die Zeilen, und du kommst auch ans Ziel, komplett ohne OOP

Ich meine sowieso, dass der Versuch weg von C hin zu einer komplexen Lösung in C++ eher Bloat verursacht, als dass es hilft. Der einzige Vorteil wird sein, dass du von dem Monster-switch in deiner main wegkommst, und die Fallunterscheidungen auslagerst - in eigene Klassen, in ein XML, usw. Es wird übersichtlicher, aber die Gefahr, dass du irgendwann nicht mehr durchblickst ist auch recht hoch. Es kommt sicher eine schönere Lösung raus, keine Frage! Aber du solltest das halt auch verstehen.

Ok, ich nehm es mir zu Herzen: Ich bleibe lieber bei meinem switch-Monster. Ich dachte in OOP währe alles einfacher, aber ich sehe für einen Neuling ist es das nicht. Vielen Dank an alle die mir geholfen haben oder es versucht haben.

Vielen Dank nochmal,

Gruß Jermuk