Inputbuffer für Spiellogik

[Laudi]

Moin Moin,

ich bin zur Zeit dabei, Python zu lernen, und als erstes "Projekt" möchte ich zur Zeit ein Kartenspiel programmieren, dass ich mit einigen Freunden häufig Spiele ^^

Ich bin jetzt mit der Server/Clientklassesoweit fertig, dass ich die Clients am Server registrieren und Nachrichten von/an Clients versenden kann. Der Server benutzt dabei n (Anzahl der Spieler) Threads, die jeweils auf einem Port lauschen und die empfangenen Nachrichten dann an die __lshift__(self, packet) der Spiellogik übergeben.

Ich bin jetzt dabei, eben diese Methode zu entwickeln. Mein Problem ist, dass die Pakete nicht parallel, sondern hintereinander verarbeitet werden sollen. Meine Vorgehensweise wäre jetzt diese:

Eine Variable self.request_is_handled die speichert, ob bereits eine Anfrage bearbeitet wird.
Die __lshift__ Methode schreibt die Pakete in eine Liste (die ich während eines Zugriffs immer locken kann) und ruft den Requesthandler auf falls self.request_is_handled == False.
Der Requesthandler wiederum arbeitet die Listenobjekte der Reihe nach ab und sobald die Liste leer ist wird self.request_is_handled = False gesetzt und der Thread des Requesthandlers geschlossen.

Meine Frage ist jetzt eigentlich, ob das Vorhaben so "ok" ist oder ob es deutlich elegantere Lösungen dafür gibt ?

MfG
Laudian

[Boa]

Normalerweise würde man dafür eine Queue verwenden. Dahinein schreiben einfach alle client Threads ihre requests.
Dann gibt es einen (main?) Thread im Server, der in einer while Schleife läuft

Code: Alles auswählen

while(new_request=queue.get()):
    process(new_request)

Du kannst natürlich die Locking Mechanismen auch selbst schreiben, allerdings ist das fehleranfälliger.

[Laudi]

Danke, von den Queues höre ich gerade zum ersten mal.
Dann werde ich die doch auch direkt verwenden

MfG
Laudian

[BlackJack]

@Laudi: Statt der Operatorüberladung würde ich absehen und lieber eine ordentlich benannte Methode verwenden. Mit so einer Verwendung können *vielleicht* C++-Programmierer richtig raten was das tut, aber sonst wahrscheinlich niemand.

[Laudi]

Hmm, hat das einen speziellen Grund ?

Genau dafür ist der << Operator und die Möglichkeit zur Operatorüberladung doch gedacht ?

Aber ja, parallel zu Python hatte ich mir auch mal ein C++ Buch angeguckt um zu sehen welche Sprache mir besser gefällt (bzw welche ich zuerst lernen möchte), daher habe ich gedachte dass das durchaus üblich wäre Informationen mit << an ein Objekt zu übergeben.

[BlackJack]

@Laudi: Was meinst Du mit speziellem Grund? Sehr viele Menschen wissen das bei ``a + b`` etwas addiert wird, also kann man den Operator überladen wenn das was ``+`` dann macht, so etwas wie eine Addition oder das Hinzufügen oder Verbinden bedeutet. Aber was macht denn bitte ``<<``? Das ist hauptsächlich als Operator für bitweises linksverschieben von Zahlen bekannt, also zumindest den Leuten die so etwas ”exotisches” machen. Daher hat die spezielle Methode dafür den Namen ``__lshift__``, also `l` wie `left`. C++ ist die einzige mir bekannte Programmiersprache die diesen Operator benutzt um Objekte in andere Objekte zu ”schieben”. Und selbsterklärend ist das nicht gerade.

[Laudi]

Ok, danke.

Da C++ die einzige Sprache neben Python ist die ich mir näher angesehen habe dachte ich, << wäre zum Übergeben von Objekten durchaus üblich.

Aber dann werde ich das doch irgendwie anders lösen

[EyDu]

Als üblich würde ich das Überladen des left-shift-Operators in C++ auch nicht bezeichnen. Das wird eigentlich nur bei Streams gemacht.

[BlackJack]

Bei Python fällt mir auf Anhieb nur ein Modul ein welches ``<<`` für etwas anderes als Bitverschiebungen überlädt. Und zwar PyParsing um ”forward declarations” später eine Grammatikregel zu ”injizieren”. Beispiel:

Code: Alles auswählen

NUMBER = Regex(r'\d+').setParseAction(lambda t: int(t[0]))
LIST = Forward()
ITEM = NUMBER | Group(LIST)
LIST <<= Suppress('<') + ZeroOrMore(ITEM) + Suppress('>')

Code: Alles auswählen

In [60]: LIST.parseString('<42 23 <4711> <> 1337>').asList()
Out[60]: [42, 23, [4711], [], 1337]