Poker Kombinationen?

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Poker Kombinationen?

    Ich hab da grad ein sehr komplexes Ding am laufen:

    Ich motze grade so nebenbei Texas ein bischen auf und habe Spielkarten als Items eingebracht. Der Spieler sammelt also 5 Karten ein und dann soll die Engine erkennen, ob, und jen ja welche Kartenkombinationen eingesammelt wurden. Dazu gibts zwei arrays:

    GML-Quellcode

    1. obj_Control.card_type[0-4]
    2. obj_Control.card_numb[0-4]

    card_type kann die Werte 1 bis 4 haben (0 ist keine Karte) und gibt an, von welchem Typ die Karte ist (Herz, Karo, Kreuz oder Pik).
    card_numb kann 0 bis 12 sein und gibt an, welche Karte es genau ist (beginnend bei 2 und endet bei Ass).

    Sind nun alle 5 Karten vollständig muss erkannt werden, ob und welche Kombination eingesammelt wurde. Dazu hier die möglichen kombinationen: wikipedia.org/wiki/Poker#Kombinationen

    Hat jemand ne Idee wie man das möglichst einfach umsetzen kann? Ich komm da auf keinen grünen Zweig, weil mir das ein bsichen zu hoch ist und ich nichtmal richtig pokern kann :D

    EDIT: also es muss der Name der (ggf. vohandenen) Kombination ausgegeben werden.
    Battle Command - WeltraumEchtzeitStrategie | Meine GM Spiele auf Box.net
    GCM/FA/O d-(--)@>---xpu s-:- !a C++$@ U- P L+ E W++ N o K-- w++ O? M V PS PE-- Y PGP t 5 X R+++ tv+ b DI D G e+ h? r-- x
  • RE: Poker Kombinationen?

    Hey. Falls dir nur ein Denkanstoß reicht, dann könntest ja "checken", ob mehrere "card_nums" gleich sind und jenachdem wie viele es sind ausgeben, ob ein Zwilling, Drilling oder Vierling.
    Dann noch abfragen, ob alle "card_types" gleich sind u.s.w.

    Ich guck mal, ob ich das schaffe. Wenn ja, dann poste ich später mal ne Demo.
  • Kombinationen wie Royal Flush oder Pärchen sind ja nicht das schwierige. Full House, Flush und die Straßen sind erst so richtig knackig. Also ich wollte erst so rangehen, das sozusagen von oben nach unten gecheckt wird. Allerdings wird das bei mir total viel code schon für die beiden Flushes.
    Battle Command - WeltraumEchtzeitStrategie | Meine GM Spiele auf Box.net
    GCM/FA/O d-(--)@>---xpu s-:- !a C++$@ U- P L+ E W++ N o K-- w++ O? M V PS PE-- Y PGP t 5 X R+++ tv+ b DI D G e+ h? r-- x
  • Also für ein Flush kann man ja folgendes nehmen:

    GML-Quellcode

    1. with(obj_control){
    2. if (card_type[0]=(card_type[1]&card_type[2]&card_type[3]&card_type[4])) {
    3. //Flush
    4. }


    Für ein Royal Flush muss dann noch das Array sortiert werden, da könnte ich mal schauen ob ich da was implementieren kann.
    "Die Erde ist ein Irrenhaus. Dabei könnte das bis heute erreichte Wissen der Menschheit aus ihr ein Paradies machen. Dafür müsste die weltweite Gesellschaft allerdings zur Vernunft kommen."
    - Joseph Weizenbaum
  • Hab dann mal das mit der Straße gecodet. Bei mir gings auf jeden schonmal^^

    GML-Quellcode

    1. var erste;
    2. erste=12
    3. for(i=0;i<5;i+=1)
    4. if card_numb[i]<erste erste=card_numb[i]
    5. if (card_numb[0]=erste+1||card_numb[1]=erste+1||card_numb[2]=erste+1||card_numb[3]=erste+1||card_numb[4]=erste+1)
    6. && (card_numb[0]=erste+2||card_numb[1]=erste+2||card_numb[2]=erste+2||card_numb[3]=erste+2||card_numb[4]=erste+2)
    7. && (card_numb[0]=erste+3||card_numb[1]=erste+3||card_numb[2]=erste+3||card_numb[3]=erste+3||card_numb[4]=erste+3)
    8. && (card_numb[0]=erste+4||card_numb[1]=erste+4||card_numb[2]=erste+4||card_numb[3]=erste+4||card_numb[4]=erste+4)
    9. if card_type[0]=card_type[1]=card_type[2]=card_type[3]=card_type[4]
    10. //straight flush
    11. else
    12. //straße
    Alles anzeigen


    EDIT: "erste" muss natürlich mit 12 und nicht 0 initialisiert werden. Habs geändert.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Superdaniel ()

  • Naja, hier mal ein paar Ansätze:
    Als erstes würde ich die Karten nach numb sortieren, das macht die Arbeit später leichter; so in etwa:

    Spoiler anzeigen

    GML-Quellcode

    1. var i,j,k,temp_type, temp_numb;
    2. temp_type[0]:=obj_Control.card_type[0];
    3. temp_numb[0]:=obj_Control.card_numb[0];
    4. for (i:=1; i<=4; i+=1)
    5. {
    6. temp_type[i]:=obj_Control.card_type[i];
    7. temp_numb[i]:=obj_Control.card_numb[i];
    8. for (j:=0; j<i; j+=1)
    9. {
    10. if (temp_numb[j]<obj_Control.card_numb[i])
    11. {
    12. for (k:=i; k>j; k-=1)
    13. {
    14. temp_type[k]:=temp_type[k-1];
    15. temp_numb[k]:=temp_numb[k-1];
    16. }
    17. temp_type[j]:=obj_Control.card_type[i];
    18. temp_numb[j]:=obj_Control.card_numb[i];
    19. }
    20. }
    21. }
    22. for (i:=0;i<=4;i+=1)
    23. {
    24. obj_Control.card_type[i]:=temp_type[i];
    25. obj_Control.card_numb[i]:=temp_numb[i];
    26. }
    Alles anzeigen


    Und dann würde ich der Reihe nach durchtesten, was er haben könnte, wobei da noch mit einfließen sollte, welche Karten jetzt an den Kombinationen beteiligt sind, falls 2 die selbe Kombination haben...

    Dabei würde ich dann auf ein Binärsystem zum Abspeichern möglicher Kombinationen zurückgreifen:
    00000 = Nischt
    00001 = 1 Paar
    00010 = 1 Paar + 1 Paar, also 2 Paar
    00100 = 1 Drilling
    00101 = 1 Paar + 1 Drilling, also Full House
    01000 = 1 Straße
    10000 = 1 Flush
    11000 = 1 Straße + 1 Flush, also Straight Flush
    Und nun nun Brauch ich noch irgendwas, um einen Vierling zu speichern, und dafür nehm ich einfach mal 00111.

    So, und da bei 5 Karten Paare/Drillinge/Vierlinge und Straßen/Flushs einander ausschließen, gibt es auch keine ungewünschten Überschneidungen, die abgefragt werden müssen.

    Nun also zu den Abfragen:

    Spoiler anzeigen

    GML-Quellcode

    1. var Kombi,count,card1,card2,i,j,ausgabe;
    2. //Initialisieren der Ergebnisvariablen
    3. Kombi:=0;
    4. card1:=-1;
    5. card2:=-1;
    6. with(obj_Controller)
    7. {
    8. //Abfrage auf mehrfach vorkommende Karten
    9. for (i:=0;i<4;i+=1) //Geht die ersten 4 Karten durch, um sie mit den folgenden zu vergleichen
    10. {
    11. if (i > 0) // überprüft, ob diese Karte bereits in einem Paar vorkommt
    12. {
    13. if (card_numb[i]==card_numb[i-1])
    14. {
    15. break;
    16. }
    17. }
    18. //Zähler initialisieren
    19. count:=1;
    20. for (j:=i+1;j<=4;j+=1)
    21. {
    22. if (card_numb[i]==card_numb[j])
    23. {
    24. count+=1; //Karten zählen
    25. }
    26. }
    27. switch(count) //Auswertung, wieviele Karten nun dran kamen
    28. {
    29. case 2:{
    30. if (Kombi != 0)
    31. {
    32. card2:=card_numb[i];
    33. }
    34. else
    35. {
    36. card1:=card_numb[i];
    37. }
    38. Kombi+=1;
    39. };break;
    40. case 3:{
    41. if (Kombi != 0)
    42. {
    43. card2:=card1;
    44. }
    45. card1:=card_numb[i];
    46. Kombi:=Kombi|4;
    47. };break;
    48. case 4:{
    49. card1:=card_numb[i];
    50. Kombi:=7;
    51. }
    52. }
    53. }
    54. //Überprüfung auf eine Straße
    55. if((Kombi=0) && (card_numb[0]==card_numb[4]+4))
    56. {
    57. Kombi:=8;
    58. }
    59. //Überprüfung auf Flush
    60. if ((card_type[0]=card_type[1]) && (card_type[1]==card_type[2]) && (card_type[2]==card_type[3]) && (card_type[3]==card_type[4]))
    61. {
    62. Kombi:=Kombi|16;
    63. }
    64. }
    Alles anzeigen


    Kurze Erklärung: Bei den Paaren addiere ich einfach nur 1 dazu, das macht aus einer 0 eine 1, aus einer 1 eine 2 und aus einer 4 eine 5, also stattet jede mögliche vorige Kombination (Nix/Paar/Drilling) mit einem weiteren Paar aus. Falls vorher schon was vorhanden war (Kombination != 0), ordnet sich dieses Paar dem anderen unter, da das andere Entweder der Drilling ist, oder das höhere Paar (die Karten sind sortiert!). Der Drilling ordnet sich in jedem Fall über, und verschiebt eine eventuelle "card1" auf "card2". Der Vierling steht immer alleine.

    Wenn keine Karten doppelt vorkommen, muss nur noch überprüft werden, ob die höchste und niedrigste genau um 4 auseinander liegen, und schon ist das Kriterium für eine Straße erfüllt.
    Für einen Flush müssen nur alle Karten die selbe Farbe haben. Da bei Flush, Straße und "Nix" alle Karten von Bedeutung sein können, kann man bei Gegenüberstellung der Blätter direkt die Karten vergleichen, während bei den übrigen schon wichtig ist, was man für Paare, Drillinge, Vierlinge hat.

    Jetzt braucht man nur noch am Ende eine vernünftige Ausgabe:

    Spoiler anzeigen

    GML-Quellcode

    1. switch(Kombi)
    2. {
    3. case 0: ausgabe:='0';break;
    4. case 1: ausgabe:='1';break;
    5. case 2: ausgabe:='2';break;
    6. case 4: ausgabe:='3';break;
    7. case 8: ausgabe:='4';break;
    8. case 16: ausgabe:='5'; break;
    9. case 5: ausgabe:='6';break;
    10. case 7: ausgabe:='7';break;
    11. case 24: ausgabe:='8';
    12. }
    13. ausgabe:=ausgabe+'_'+card1+'_'+card2;
    14. return ausgabe;
    Alles anzeigen


    In einem Skript verpackt sollte dies jetzt einen Ergebnisstring ausgeben: Zuerst eine Zahl von 0 bis 8, wobei 0 für High Card, und 8 für Straight Flush steht, und danach, jeweils getrennt durch "_", die variablen "card1" und "card2". Dieser String muss dann beim Vergleichen nur noch ausgewertet werden, aber ich denke mal, das dürfte dann nicht mehr das Problem sein.

    (Und nun hoffe ich, dass das Problem inzwischen noch nicht gelöst wurde...)
  • @CAS:
    Theoretisch kann ich dir einigermaßen folgen. (ach, wär ich doch nicht so schlecht in Mathe!)

    Leider habe ich wohl einen Fehler eingebaut oder so, denn das script, erkennt die kombinationen nicht richtig:

    Spoiler anzeigen

    GML-Quellcode

    1. // -------------------------------------------------------
    2. // Sortieren
    3. var i,j,k,temp_type, temp_numb;
    4. temp_type[0]:=card_type[0];
    5. temp_numb[0]:=card_numb[0];
    6. for (i:=1; i<=4; i+=1)
    7. {
    8. temp_type[i]:=card_type[i];
    9. temp_numb[i]:=card_numb[i];
    10. for (j:=0; j<i; j+=1)
    11. {
    12. if (temp_numb[j]<card_numb[i])
    13. {
    14. for (k:=i; k>j; k-=1)
    15. {
    16. temp_type[k]:=temp_type[k-1];
    17. temp_numb[k]:=temp_numb[k-1];
    18. }
    19. temp_type[j]:=card_type[i];
    20. temp_numb[j]:=card_numb[i];
    21. }
    22. }
    23. }
    24. for (i:=0;i<=4;i+=1)
    25. {
    26. card_type[i]:=temp_type[i];
    27. card_numb[i]:=temp_numb[i];
    28. }
    29. // -------------------------------------------------------
    30. // Abfragen
    31. var Kombi,count,card1,card2,i,j,ausgabe;
    32. //Initialisieren der Ergebnisvariablen
    33. Kombi:=0;
    34. card1:=-1;
    35. card2:=-1;
    36. //Abfrage auf mehrfach vorkommende Karten
    37. for (i:=0;i<4;i+=1) //Geht die ersten 4 Karten durch, um sie mit den folgenden zu vergleichen
    38. {
    39. if (i > 0) // überprüft, ob diese Karte bereits in einem Paar vorkommt
    40. {
    41. if (card_numb[i]==card_numb[i-1])
    42. {
    43. break;
    44. }
    45. //Zähler initialisieren
    46. count:=1;
    47. for (j:=i+1;j<=4;j+=1)
    48. {
    49. if (card_numb[i]==card_numb[j])
    50. {
    51. count+=1; //Karten zählen
    52. }
    53. }
    54. switch(count) //Auswertung, wieviele Karten nun dran kamen
    55. {
    56. case 2:{
    57. if (Kombi != 0)
    58. {
    59. card2:=card_numb[i];
    60. }
    61. else
    62. {
    63. card1:=card_numb[i];
    64. }
    65. Kombi+=1;
    66. };break;
    67. case 3:{
    68. if (Kombi != 0)
    69. {
    70. card2:=card1;
    71. }
    72. card1:=card_numb[i];
    73. Kombi:=Kombi|4;
    74. };break;
    75. case 4:{
    76. card1:=card_numb[i];
    77. Kombi:=7;
    78. }
    79. }
    80. }
    81. //Überprüfung auf eine Straße
    82. if((Kombi=0) && (card_numb[0]==card_numb[4]+4))
    83. {
    84. Kombi:=8;
    85. }
    86. //Überprüfung auf Flush
    87. if ((card_type[0]==card_type[1]) && (card_type[1]==card_type[2]) && (card_type[2]==card_type[3]) && (card_type[3]==card_type[4]))
    88. {
    89. Kombi:=Kombi|16;
    90. }
    91. }
    92. // -------------------------------------------------------
    93. // Ausgabe
    94. switch(Kombi)
    95. {
    96. case 0: ausgabe:='High Card';break;
    97. case 1: ausgabe:='One Pair';break;
    98. case 2: ausgabe:='Two Pair';break;
    99. case 4: ausgabe:='Three of a Kind';break;
    100. case 8: ausgabe:='Straight';break;
    101. case 16: ausgabe:='Flush'; break;
    102. case 5: ausgabe:='Full House';break;
    103. case 7: ausgabe:='Four of a Kind';break;
    104. case 24: ausgabe:='Straight Flush';
    105. }
    106. text='Ausgabe: '+string(ausgabe);
    107. text+='#Card1: '+string(card1);
    108. text+='#Card2: '+string(card2);
    109. text+='#Kombi: '+string(Kombi);
    110. show_message(text);
    Alles anzeigen


    Es ekennt keine pairs und hällt einen Drilling für ein Flush. Leider schnall ich die Zuteilung nicht richtig, so das ich sie nicht wirklich nachvollziehen kann. Eventuell weil das Ass am Ende und nicht am Anfang der Kartenreihe steht? Aber das müsste doch eigentlich egal sein oder?

    zudem waren zwei tippfehler (ein Zwiebelfisch und ein "l" bei "obj_Control" zu viel) in deinem code, die ich mir mal erlaubt habe in deinem post zu verbessern.

    @Superdaniel:
    genau so ein script hatte ich vorher ja auch schon, jedoch wollte ich jede Abfrage einzeln zu coden genau vermeiden.

    EDIT: finde ich nebenbei sehr krass, daß ihr sowas komplett theoretisch aufbauen könnt, wärend ich immer genauso lange bugtesten muss um sowas zu basteln :D
    Battle Command - WeltraumEchtzeitStrategie | Meine GM Spiele auf Box.net
    GCM/FA/O d-(--)@>---xpu s-:- !a C++$@ U- P L+ E W++ N o K-- w++ O? M V PS PE-- Y PGP t 5 X R+++ tv+ b DI D G e+ h? r-- x
  • Nunja, ein eigenes Poker Spiel macht nochmehr Aufwand, weil es noch viel mehr zu berechnen, speichern und vergleichen gibt, z.B. die höhe des Paares und die Beikarten.
    Nun, leider bin habe ich keine Ahnung von GML, habe das ganze mal in Python umgesetzt:
    phpfi.com/249341

    Die Funktionsweise ist imo wesentlich komplizierter als die von CAS, und der Code ist recht unverständlich, vor allem, weil ich zu faul für Kommentare war. Hier mal die Technik, um Päärchen und Co zu finden:

    Die Werte der Karten werden zunächst in zweierpotenzen umgerechnet. Aus 0 wird 1, aus 1 wird 2, aus 2 wird 4, aus 3 wird 8 usw. Interesant sind die Zahlen in binärer Darstellung:

    Quellcode

    1. 0 1 00001
    2. 1 2 00010
    3. 2 4 00100
    4. 3 8 01000

    Die erste Karte wird nun als Basis genommen. Ins Spiel kommt nun Bitweises ODER. Nacheinander werden die einzelnen Werte mit ODER (a | b) verknüpft. Das Ergebnis, wenn ich 2 unterschiedliche Kartenwerte miteinander verknüpfe ist eine Zahl, in der an den entsprechenden Positionen binär gesehen eine 1 steht. Verknüpfe ich eine Zahl, in der an der Position bereits eine 1 steht bleibt der Wert unverändert. Ich habe also in diesem Fall ein Päärchen gefunden. Dieses Speichere ich in einer weiteren Zahl. Wenn sich bei einem erneuten verknüpfen mit ODER nocheinmal die Zahl nicht verändert dann verknüpfe ich auch diese Zahl mit der Zahl, die ich beim ersten Päärchen gespeichert habe. Bleibt diese Zahl unverändert habe ich einen Drilling, ansonsten habe ich ein zweites Päärchen. Sorry, wenn es nicht verständlich ist, aber es fällt mir schwer, das zu erklären. Verständnis des ODER-Operators wird vorrausgesetzt ;)
  • Ok, zuerst einmal entschuldige ich mich für den hingeschmierten Code, aber das war quasi nur ein erster Entwurf, den ich hier einfach mal weggetippt hatte, in der Annahme, dass er funktioniert, und der Hoffnung, dass du die Fehler von allein finden würdest, wenn sie auftauchen...

    Zuerst einmal fehlte beim Sortieralgorithmus ein "break", welches dafür sorgte, dass z.B. aus "12345" "55554" wird.

    Als nächstes hatte ich vergessen, dass eine Straße auch mit einem Ass beginnen kann, und dass dies als Sonderfall behandelt werden muss, da das Ass neben der 5 einsortiert wird.

    Und zum Schluss habe ich vergessen, dass ein "break" in einer For-Schleife die ganze Schleife beendet, und nicht nur den momentanen Durchlauf, weswegen die Karten nie richtig ausgewertet wurden, wenn ein Paar auftrat. Leider fiel mir auf die schnelle keine Elegantere Lösung ein, als einen Teil des Codes doppelt zu schreiben...

    Das korrigierte Skript, das zumindest bei mir in einer Testumgebung funktioniert hat sieht dann so aus:

    Spoiler anzeigen

    GML-Quellcode

    1. // -------------------------------------------------------
    2. // Sortieren
    3. var i, j, k, temp_type, temp_numb, Kombi, count, card1, card2, ausgabe;
    4. temp_type[0]:=card_type[0];
    5. temp_numb[0]:=card_numb[0];
    6. for (i:=1; i<=4; i+=1)
    7. {
    8. temp_type[i]:=card_type[i];
    9. temp_numb[i]:=card_numb[i];
    10. for (j:=0; j<i; j+=1)
    11. {
    12. if (temp_numb[j]<card_numb[i])
    13. {
    14. for (k:=i; k>j; k-=1)
    15. {
    16. temp_type[k]:=temp_type[k-1];
    17. temp_numb[k]:=temp_numb[k-1];
    18. }
    19. temp_type[j]:=card_type[i];
    20. temp_numb[j]:=card_numb[i];
    21. break;
    22. }
    23. }
    24. }
    25. for (i:=0;i<=4;i+=1)
    26. {
    27. card_type[i]:=temp_type[i];
    28. card_numb[i]:=temp_numb[i];
    29. }
    30. // -------------------------------------------------------
    31. // Abfragen
    32. //Initialisieren der Ergebnisvariablen
    33. Kombi:=0;
    34. card1:=-1;
    35. card2:=-1;
    36. //Abfrage auf mehrfach vorkommende Karten
    37. //Karte 0
    38. //Zähler initialisieren
    39. count:=1;
    40. for (j:=1;j<=4;j+=1)
    41. {
    42. if (card_numb[0]==card_numb[j])
    43. {
    44. count+=1; //Karten zählen
    45. }
    46. }
    47. switch(count) //Auswertung, wieviele Karten nun dran kamen
    48. {
    49. case 2:{
    50. card1:=card_numb[0];
    51. Kombi+=1;
    52. };break;
    53. case 3:{
    54. card1:=card_numb[0];
    55. Kombi:=Kombi|4;
    56. };break;
    57. case 4:{
    58. card1:=card_numb[0];
    59. Kombi:=7;
    60. }
    61. }
    62. //Die restlichen Karten
    63. for (i:=1;i<4;i+=1) //Geht die ersten 4 Karten durch, um sie mit den folgenden zu vergleichen
    64. {
    65. // überprüft, ob diese Karte bereits in einem Paar vorkommt
    66. if (card_numb[i]!=card_numb[i-1])
    67. {
    68. //Zähler initialisieren
    69. count:=1;
    70. for (j:=i+1;j<=4;j+=1)
    71. {
    72. if (card_numb[i]==card_numb[j])
    73. {
    74. count+=1; //Karten zählen
    75. }
    76. }
    77. switch(count) //Auswertung, wieviele Karten nun dran kamen
    78. {
    79. case 2:{
    80. if (Kombi != 0)
    81. {
    82. card2:=card_numb[i];
    83. }
    84. else
    85. {
    86. card1:=card_numb[i];
    87. }
    88. Kombi+=1;
    89. };break;
    90. case 3:{
    91. if (Kombi != 0)
    92. {
    93. card2:=card1;
    94. }
    95. card1:=card_numb[i];
    96. Kombi:=Kombi|4;
    97. };break;
    98. case 4:{
    99. card1:=card_numb[i];
    100. Kombi:=7;
    101. }
    102. }
    103. }
    104. }
    105. //Überprüfung auf eine Straße
    106. if((Kombi=0) && ((card_numb[0]==card_numb[4]+4) || ((card_numb[0]==12)&&(card_numb[1]==3))))
    107. {
    108. Kombi:=8;
    109. }
    110. //Überprüfung auf Flush
    111. if ((card_type[0]==card_type[1]) && (card_type[1]==card_type[2]) && (card_type[2]==card_type[3]) && (card_type[3]==card_type[4]))
    112. {
    113. Kombi:=Kombi|16;
    114. }
    115. // -------------------------------------------------------
    116. // Ausgabe
    117. ausgabe='Error!';
    118. switch(Kombi)
    119. {
    120. case 0: ausgabe:='High Card';break;
    121. case 1: ausgabe:='One Pair';break;
    122. case 2: ausgabe:='Two Pair';break;
    123. case 4: ausgabe:='Three of a Kind';break;
    124. case 8: ausgabe:='Straight';break;
    125. case 16: ausgabe:='Flush'; break;
    126. case 5: ausgabe:='Full House';break;
    127. case 7: ausgabe:='Four of o Kind';break;
    128. case 24: ausgabe:='Straight Flush';
    129. }
    130. ausgabe:=ausgabe+'_'+string(card1)+'_'+string(card2);
    131. return ausgabe;
    Alles anzeigen
  • Ok, zuerst einmal entschuldige ich mich für den hingeschmierten Code, aber das war quasi nur ein erster Entwurf, den ich hier einfach mal weggetippt hatte, in der Annahme, dass er funktioniert, und der Hoffnung, dass du die Fehler von allein finden würdest, wenn sie auftauchen...

    dafür brauchst du dich doch nicht zu entschuldigen. Ich finde sogar im gegentell, das du mir schon sehr geholfen hast. Zwar hab ich den code nicht ganz verstanden, und von selbst verbessern konnte ich den auch nicht, aber du bewartest mich so vor seitenlangen If-konstellationen. Schließlich ist die Auswertung von Pokerkombinationen ein wenig komplexer als ein Tic-Tac-Toe script. Zu spielst doch bestimmt auch poker oder?
    Ich werde den code nachher mal einbauen und berichten wie es läuft.
    Vielen dank aber schonmal für die umfangreiche hilfe :)
    Battle Command - WeltraumEchtzeitStrategie | Meine GM Spiele auf Box.net
    GCM/FA/O d-(--)@>---xpu s-:- !a C++$@ U- P L+ E W++ N o K-- w++ O? M V PS PE-- Y PGP t 5 X R+++ tv+ b DI D G e+ h? r-- x
  • Mal sehn, ich kann jetzt leider nicht die Gewinnroutinen meiner Firma hereingeben (aus gutem Grund), aber ich persönlich würde das ganze so angehen:

    Die Karten selbst werden in einer Varialbe gespeichert. Also nur ein Array, nicht 2. Die Karte selbst sieht so aus: die ersten 13 stellen sind der Wert der Karte, also von 2 - Ace. die letzten 4 Stellen sind die Farben. Das sieht dann so aus:

    Quellcode

    1. 16-15-14-13-12-11-10-09-08-07-06-05-04-03-02-01-00
    2. HE-KA-KR-PI- A- K- Q- J-10- 9- 8- 7- 6- 5- 4- 3- 2

    Eine Herz 10 hätte also einen wert von 263168, das ist 2 hoch 10 + 2 hoch 18. Der Witz hinter diesem System liegt, das man beinahe alle Kombinationen durch binäre Operationen herausfindet. Wir brauchen erstmal eine Funktion die uns nur den Farbwert und nur den Kartenwert zurückgeben.

    Diese Funktion macht nichts anderes als ein binäres UND mit der Karte mit dem Wert 111100000000000000. Es bleiben nurmehr die Farberte übrig.

    GML-Quellcode

    1. function GetCardColor(argument0)
    2. {
    3. //argument 0 ... Card
    4. return (Card & 245760);
    5. }


    Diese Funktion macht nichts anderes als ein binäres UND mit der Karte mit dem Wert 000011111111111111. Es bleiben nurmehr die Farberte übrig.

    GML-Quellcode

    1. function GetCardValue(argument0)
    2. {
    3. //argument 0 ... Card
    4. return (Card & 16383);
    5. }


    Das Array, welches bereits die 5 Karten beinhaltet, muß jetzt nach dem Kartenwert absteigend sortiert werden (also höchste Karten vorne, niedrigste hinten im Array).

    Jetzt braucht man noch einige Hilfsroutinen, wie z.b. IsStraight, welche ansagen, ob 5 Karten direkt hintereinander liegen. Sie macht nichts anderes als die Verknüpften Karten so lange nach rechts bitshiften bis auf der Position 0 eine 1 ist (also aus 00011111000b wird 00000011111b). Dann das ganze mit der Zahl 11111b vergleichen, und schon weiß man obs ein Straight ist.

    GML-Quellcode

    1. function IsStright(argument0)
    2. {
    3. //argument 0 ... all 5 cards connected via |
    4. // like card[0]|card[1]|card[2]|card[3]|card[4]
    5. var TmpVar;
    6. TmpVar = argument0;
    7. while(!(TmpVar&1))
    8. {
    9. TmpVar = TmpVar>>1;
    10. }
    11. if(TmpVar == 31) return true;
    12. return false;
    13. }
    Alles anzeigen


    Die Gewinnroutine für den Royal Flush würde dann so aussehen:

    GML-Quellcode

    1. {
    2. CombinedCards = Card[0]|Card[1]|Card[2]|Card[3]|Card[4];
    3. if( IsStraight(CombinedCards) && IsSameColor(CombinedCards) )
    4. return irgendwas
    5. }


    Das ganze läßt sich vorzüglich mit dem Denkansatz von CAS kombinieren, in dem die IsIrgendwas funktionen auch wieder Binäre werte zurückgeben, welche wieder mit einem binären ODER verbunden werden. Mann hätte dann z.b. Funktionen wie

    Quellcode

    1. 0001 IsPair
    2. 0010 IsTripple,
    3. 0100 IsStright,
    4. 1000 IsSameColor


    ein Wert von 1100 währe dann z.b. ein Royal Flush. 0011 währe eine Straße.
    ...
  • Vieln dank für eure umfangreiche Hilfe! :)
    Die Funktion die CAS gebaut hat funktioniert für meine Zwecke schon sehr gut. Es ist ja kein richtiges Pokerspiel, sondern schlichtes sammeln von Karten. Jedoch haben wir jetzt auch einen tread der Hilfstellung zu pokerspielen bietet.
    Also vielen dank den guten Proggern hier! :kiss:

    *gelöst*
    Battle Command - WeltraumEchtzeitStrategie | Meine GM Spiele auf Box.net
    GCM/FA/O d-(--)@>---xpu s-:- !a C++$@ U- P L+ E W++ N o K-- w++ O? M V PS PE-- Y PGP t 5 X R+++ tv+ b DI D G e+ h? r-- x
  • Benutzer online 1

    1 Besucher