Hallo,

ich möchte gerne ein Pokerspiel in C# umsetzen.
Bisher gabs kaum Probleme und ich hab erstmal alle möglichen Funktionalitäten implementiert, wie z.B:
Kartenklasse, Deckklasse, Playerklasse, Ki, etc..

Nun wollte ich mich eigentlich an den Ablauf einer Spielrunde setzen, dass heißt:
Handkarten verteilen
Blinds kassieren
WETTRUNDE
Flop ausgeben
WETTRUNDE
Turn ausgeben
WETTRUNDE
River ausgeben
WETTRUNDE
Analyse wer gewonne hat
Potausteilung

Wie geasgt die ganzen Funktionen funktionieren schon, dass einzige Problem besteht bei der Wettrunde.
Hier hat der User als einziges die Möglichkeit aktiv in das Spiel einzugreifen, der Rest passiert automatisch ohne ihn.
Ich arbeite mit WPF, also soll, wenn der Spieler an der Reihe ist, er die Möglichkeit haben über sagen wir einfach 3 Buttons zu entscheiden ob er callen, raisen oder folden will.

Ich hab versucht das in einer Methode umzusetzen, hat aber überhaupt nicht funktioniert. Ich bin dann auf den Begriff Events gestoßen, ich finde aber leider keinerlei Ansatz wie ich das jetzt lösen könnte... Könntet ihr mir helfen in die richtige Richtung zu kommen?

Wie wäre es denn wenn du einfach ein neues Window (auf dem du die Auswahl stellst) per ShowDialog aufrufst?
Da würde es erst weitergehen wenn das Window geschlossen wurde. Das Ergebnis kannst du ja entweder über eine Property auf dem Fenster zurückholen oder mit dem DialogResult zurückgeben.
Man bräuchte keine Events und solange die Auswahl nicht getroffen wurde muss ja eh nichts anderes passieren.

Hey, das ist ja eigentlich total clever!
Kann man das Window eventuell auch so aussehen lassen, das es lediglich so aussieht, als wenn 3 Buttons visibible gemacht werden?

Hallo zusammen,

jedoch sollte eine Logik-Klasse niemals direkt GUI-Funktionalität besitzen, d.h. der richtige Weg wäre doch über ein Ereignis (Event).
Und die GUI meldet sich an diesem Event an und zeigt dann in ihrer Event-Methode das Fenster an und gibt den (oder mehrere) Rückgabewert(e) wieder als Event-Arguments zurück an die Logik-Klasse.

Mein Tutorial Kommunikation von 2 Forms behandelt auch das Erstellen von Ereignissen und Übergeben von Ereignis-Parametern.

Th69 hat folgendes geschrieben :

jedoch sollte eine Logik-Klasse niemals direkt GUI-Funktionalität besitzen

Da hast du natürlich Recht.
Ich bin davon ausgegangen das es aus dem Hauptform aufgerufen wird habe aber nicht beachtet das ja der Zeitpunkt wann die Eingabe benötigt wird von der der Spielklasse (die die Runde steuert) kommen und somit als Event werden muss.

Ich hab jetzt noch nicht ganz verstanden, wo ich jetzt Events deklarieren muss und wo nicht, also ob ich da jetzt jedesmal ne eigene Klasse bauen muss oder so..

Ich hab eine Klasse Table, in der soll eigentlich der gesamte Ablauf einer Spielrunde gesteuert werden.
Das heißt ich hab dort ne Methode:
giveHandcards();
getAllBlinds();
getFlop();
getTurn();
getRiver();


Rein theoretisch, müsste der Table irgendwie zuerst die giveHandcards aufrufen, dann die getAllBlinds (alles über Events?!) und jetzt müsste man irgendwie zurück auf's Gui verweisen wo der Player seine Aktion auswählen kann. Je nachdem was er gewählt hat müsste man also unterschiedliche Abläufe verbinden. Ich hab mir jetzt bestimmt schon 20 Tutorials und Erklärungen dazu durchgelesen, aber irgendwie schein ich das Prinzip nicht zu verstehen. Deklariere ich jetzt im Gui die Events? Welche Events deklariere ich überhaupt? Wo definiere ich was geschieht...

So viele Fragen

sicLotus hat folgendes geschrieben :

jetzt müsste man irgendwie zurück auf's Gui verweisen wo der Player seine Aktion auswählen kann.

Genau das ist der Part wo die Events ins Spiel kommen.
Deine Table braucht ein Event (nennen wir es einfach mal "PlayerActionRequired") das von deiner Table ausgelöst wird wenn du für einen Spieler die Aktion brauchst.

Deine Oberfläche muss dieses Event natürlich vorher (am besten vor Spielstart) abonieren.

Dadurch wird die Oberfläche von der Table benachrichtigt sobald ein Spielzug erforderlich ist.
Im Eventhandler auf der Oberfläche kannst du dir dann die Werte holen (z.B. über ein Window mit ShowDialog wie oben schon erwähnt) und per Rückgabewert oder EventArguments wird somit das Ergebniss direkt in der Table verfügbar (da wo du das Event ausgelöst hast).

So hätte ich mir das zumindest aus den Fingern gesaugt.

Erstmal vielen vielen vielen Dank an dich!

Du bist der erste der sich endlich mal bemüht mich nicht nur auf irgendeinen Link zu verweisen, sondern auch mal auf meine Problematik eingeht.

Ich versuch nochmal zu resümieren:
Ich erzeuge im GUI eine Instanz von der Klasse Table.
Table besitzt ein einziges Event, das darauf wartet, das ein Spieler eine Aktion vornimmt.
Mein GUI muss dieses Event abonnieren.
In der GUI ist ein EventHandler für das Event im Table. Das heißt, hier müsste ich z.B. hineinschreiben, dass die 3 Buttons visible gemacht werden sollen und dann die Werte irgendwie über EventArguments an das Event in der Table übergeben.

Das heißt, ich könnte in der Table eine Funktion schreiben die so aussieht:


Ist das so korrekt?

Prinzipiell ja aber ein bischen Feinschliff braucht die Sache schon noch. z.B. gibt es ja bestimmt nicht nur 1 Spieler und für Züge der KI brauchst du das Event ja nicht usw.
außerdem muss deine Table ja auch noch andere Events haben um z.B. die gezogenen Karten anzuzeigen und deine Ausgaben zu aktualisieren.

Ich hätte nochmal eine Frage.

Ich möchte jetzt über ein Event im Table zum Gui springen und das Gui soll mir 3 Buttons (Call, Raise, Fold) sichtbar machen.
Jetzt soll quasi das Gui stehen bleiben, warten, was auch immer... und erst wenn ich Button geklickt wurde, soll es beim Table weiter gehen.

Meine Idee war jetzt folgendes:

Im Table folgende Methode:


Dann springt er zum Gui und macht die Buttons sichtbar.
In der Gui gibts ja dann für jeden Button ein Klick-Event und dieses ruft irgendeine Methode im Table auf, wo es dann weiter geht..
das sollte doch so funktionieren oder?


Edit:
Du meintest vorhin, ich müsste das Karten zeichnen/anzeigen auch in Events verpacken, muss ich das machen? Rein theoretisch hab ich die Karten in einer Instanzvariablen von der Klasse Table gespeichert. Darauf könnte ich über Attribute/Getter zugreifen und somit auch anzeigen lassen. Wäre doch viel einfacher oder?

sicLotus hat folgendes geschrieben :

In der Gui gibts ja dann für jeden Button ein Klick-Event und dieses ruft irgendeine Methode im Table auf, wo es dann weiter geht.. das sollte doch so funktionieren oder?

Theoretisch ja. Aber was passiert wenn diese Methode aufgerufen wird wenn nicht gerade auf eine Spieleraktion gewartet wird oder die Zugeingabe eines anderen Spielers gegeben wird? d.H. deine Table muss sich merken ob sie gerade auf eine solche Aktion (und von wem) wartet oder nicht und wenn die Methode aufgerufen wird während nicht darauf gwartet wird sollte sie auch entsprechend reagieren (Exception).

sicLotus hat folgendes geschrieben :

Rein theoretisch hab ich die Karten in einer Instanzvariablen von der Klasse Table gespeichert. Darauf könnte ich über Attribute/Getter zugreifen und somit auch anzeigen lassen. Wäre doch viel einfacher oder?

Und woher soll deine GUI dann wissen wann sich der Status geändert hat (z.B. wann neue Karten verteilt wurden die jetzt angezeigt werden müssten) ?