Strukturierte Variablen überprüfen

[Rebon]

Hallo Rebon,

ich wandle die Karten ja auch in Werte um, nur das ich auf das binäre Stellenwertsystem als Codierungsgrundlage zurückgreifen würde. Das schließt es nämlich aus dass es beim Addieren dazu kommt dass Summen zustande kommen die durch unterschiedliche Kartenkonstellationen entstehen und damit nicht mehr eindeutig wären....

Dann habe ich das falsch verstanden, kenne mich mit Bitmasken nicht so gut aus, aber du hattest von den Shift Operatoren geschrieben, die sind doch dafür da um die Bits zu verschieben? Oder würdest du für jede Kartenkonstellation eine Bitmaske erstellen? Dann habe ich wohl nicht verstanden für welchen Zweck diese Operatoren dienen.

Jedenfalls gerade beim Royal Flush gibt es eine Besonderheit mit den Farben, ich glaube Pik schlägt alle anderen, wobei bei Texas Hold'em durch die Gemeinschaftskarten, es mathematisch gar nicht möglich wäre, das zwei Royal Flush aufeinander treffen, schon gar nicht mit unterschiedlichen Farben.

[NicknameFJ]

Hallo Rebon,

ich fand Deinen Ansatz jeder Karte einen Wert zu geben, diese Werte aufzuaddieren und das Ergebnis mit bestimmten Werten zu vergleichen - um z.B. Royal Flash, Straight Flash, Full House und was es so alles gibt zu erkennen - einfach nur GENIAL. Ich wäre da niemals selbst draufgekommen - Respekt


Dein Ansatz hat aber drei Schwachstellen die ich mit meinem Ansatz vermeiden wollte, bzw. relativ einfach über logische Operationen (AND bzw. OR - Bitmustervergleiche etc.) ausblenden kann

1. Wie Du selbst schon angemerkt hast, kannst Du bei Deinem System der Wertigkeit der Karten nicht ausschließen das unterschiedliche Kartenkombinationen evtl. den selben Wert liefern. Mein Konzept die Wertigkeit der Karten anhand 2ér Potenzen vorzunehmen umgeht das Problem, da es niemals eintreten kann dass unterschiedliche Kombinationen den selben Wert liefern.

2. Du unterscheidest in Deinem Beispiel mit dem Royal Flash in deinem Ersten Post nicht nach Farben (ich denke die Karten müssen die gleichen Farben haben?) - kenne mich aber mit Pokern nicht aus.

3. Du musst ja sieben Karten berücksichtigen von den Du dann aber nur 5 zur Bildung der Summe berücksichtigen darfst. Wie kannst Du wissen welche Karten Du zur Summenbildung verwendet kannst? Wenn Du einfach alle sieben Karten aufaddierst wirst Du als Ergebnis niemals die z.B. zum Royal Flash gehörige Summe erhalten. Auch das kann bei meinem System mit einer einfachen AND-Operation auf Bit-Ebene gelöst werden. Ich addiere alle sieben Karten, mache eine AND-Verknüpfung mit dem Bitmuster für Royal-Flash. Wenn das Ergebnis wieder das Bitmuster Royal Flash ist stören auch die überflüssigen Karten nicht. Weiterhin kann ich dann auch mit einem weiteren Bitmuster das den eigenen Karten entspricht (Texas Hold em!) prüfen ob die eigenen Karten hierin auch beide enthalten sind oder ob der "Treffer" vielleicht nur aus dem für alle Spieler vorliegenden Pott (heist das so?) gebildet wurde.


Ich wollte Dein System keinesfalls kritisieren, im Gegenteil ich fand die Idee echt genial. Wollte hier nur ein paar Verbesserungsvorschläge machen.

Zu deiner Frage mit den Schiebeoperatoren << und >>:

Wenn Du dann auf Bitebene mit Bitmustervergleichen arbeitest musst du Du Bitmuster manchmal an die Wertigkeit anpassen bzw. auf bestimmte Positionen (Gruppen von Bits) zugreifen. Die Anpassung der Bitmuster kann dann über Multiplikation / Division mit 2ér-Potenzen erfolgen. Multipl. bzw. Division mit 2ér-Potenzen entspricht aber gerade den Schiebeoperationen << und >>.

Beispiel: ich weiß nicht ob es sowas beim Texas hold em gibt - Straße mit Karten 2-5
Mein Bitmuster wäre %000000001111
mit einer einfachen Linksverschiebung des Bitmusters (=Multiplikation mit 2) ergibt sich als neues Bitmuster %000000011110 mit dem ich bei meinem System auf die Straße mit den Karten 3-6 prüfen kann usw. da bei mir jede Bitposition (Bit 0-12) direkt einer Karte (2-Ass) zugeordnet ist.

NicknameFJ

[Rebon]

Erstmal vielen Dank für die Blumen, NicknameFJ, aber ich fürchte so genial war die Idee dann auch wieder nicht. Du hast recht, man müsste bei 7 Karten, die 2 Karten des Spielers jeweils einzeln und am Schluss zusammen, immer wieder addieren und auch noch am Ende alle Ergebnisse vergleichen.

Aber jetzt ist mir zumindest klar weshalb du diese Variante gebracht hast, auch wenn ich mich damit nicht besonders auskenne.

Auch wenn es viel mehr Aufwand zum Programmieren bedeuten würde, wäre es dann von der Geschwindigkeit möglicherweise am besten, alle möglichen Kombinationen zwischen den 2 und 5 Karten und die dann daraus resultierende bestmögliche Hand jeweils abzuspeichern.

Bei 52 Karten wäre dieses zwar ein großer Aufwand, aber dann hätte man quasi sofort das Ergebnis, ohne die Karten immer austauschen und kombinieren zu müssen.

[STARGÅTE]

Irgendwie habe ich nicht alles vom Thema mitbekommen.
Aber als ich jetzt Poker gelesen habe, und Wertigkeit des Blattes, habe ich mal meinen alten Code rausgeholt.

Mit ihm kann über die 7 Karten (2+7) und deren Wert und Farbe eine einzelne Zahl als Wertigkeit des gesamten Blatts bestimmt werden.
Sry für den schlechten Code-Stil, aber der Code ist schon sehr alt, aber vllt ist er ja trotzdem noch nützlich.
Die Karten liegen in einem Array, die definition einer Karte ist oben angegegen.

Code: Alles auswählen

Global Dim Karte(6)

; $20 - 2
; $30 - 3
; $40 - 4
; $50 - 5
; $60 - 6
; $70 - 7
; $80 - 8
; $90 - 9
; $A0 - 10
; $B0 - J
; $C0 - D
; $D0 - K
; $E0 - A

; $01 - Karo
; $02 - Herz
; $03 - Pik
; $04 - Kreuz

; Wertigkeit des Blatts
; $0 - Höchste Karte
; $1 - ein Paar
; $2 - zwei Paare
; $3 - Drilling
; $4 - Straße
; $5 - Flush
; $6 - Full House
; $7 - Vierling
; $8 - Str Flush

Procedure Wert(Hex)
 ProcedureReturn Round(Hex/16,0)
EndProcedure
Procedure Farbe(Hex)
 ProcedureReturn Pow(2,Hex-Wert(Hex)*16-1)
EndProcedure

Procedure BlattWertigkeit()
 Dim TempKarte(6)
 Dim TempKarteWert(6)
 Dim TempKarteFarbe(6)
 Dim TempFarbe(8)
 For n = 0 To 6 :
  TempKarte(n) = Karte(n) 
 Next n
 SortArray(TempKarte(), 1) 
 For n = 0 To 6
  TempKarteWert(n) = Wert(TempKarte(n))
  TempKarteFarbe(n) = Farbe(TempKarte(n))
 Next n
 Blatt = 0
 ; Str Flush
 Strasse = 0
 For n = 0 To 2 :
  If Strasse < TempKarteWert(n)
   If TempKarteWert(n+1)+1 = TempKarteWert(n) And TempKarteWert(n+2)-2 = TempKarteWert(n) And TempKarteWert(n+3)-3 = TempKarteWert(n) And TempKarteWert(n+4)-4 = TempKarteWert(n):
    Strasse = TempKarteWert(n)
    Temp = 0
    For m = n To n+4
     Temp = Temp|TempKarteFarbe(m)
    Next m
    If Temp = TempKarteFarbe(n)
     Blatt = $800000+Pow(16,4)*Strasse
    EndIf
   EndIf
  EndIf
 Next n
 If Blatt = 0 
  ; Vierling
  Vierer = 0
  For n = 0 To 3 :
   If TempKarteWert(n) = TempKarteWert(n+3) :
    Vierer = TempKarteWert(n)
    If Vierer 
     If n 
      Blatt = $700000+Pow(16,4)*Vierer+Pow(16,3)*TempKarteWert(0)
     Else
      Blatt = $700000+Pow(16,4)*Vierer+Pow(16,3)*TempKarteWert(4)    
     EndIf 
    EndIf
   EndIf
  Next n
  If Blatt = 0
   ; Full House
   Dreier = 0
   For n = 0 To 4 :
    If TempKarteWert(n) = TempKarteWert(n+2) And TempKarteWert(n) > Dreier :
     Dreier = TempKarteWert(n)
    EndIf
   Next n
   Paar = 0
   For n = 0 To 5 :
    If TempKarteWert(n) = TempKarteWert(n+1) And TempKarteWert(n) <> Dreier And TempKarteWert(n) > Paar :
     Paar = TempKarteWert(n)
    EndIf
   Next n
   If Dreier And Paar
    Blatt = $600000+Pow(16,4)*Dreier+Pow(16,3)*Paar
   EndIf
   If Blatt = 0
    ; Flush
    For n = 0 To 6 :
     TempFarbe(TempKarteFarbe(n)) + 1
    Next n
    For f = 1 To 4 :
     Wert = Pow(2,f-1)
     If TempFarbe(Wert) >= 5
      i = 5
      Blatt = $500000
      For n = 0 To 6
       If TempKarteFarbe(n) = f And i
        i-1
        Blatt + Pow(16,i)*TempKarteWert(n)
       EndIf
      Next n
     EndIf
    Next f
    If Blatt = 0
     ; Straße
     If Strasse
      Blatt = $400000+Pow(16,4)*Strasse
     EndIf
     If Blatt = 0
      ; Dreier
      If Dreier
       Blatt = $300000+Pow(16,4)*Dreier
       i = 4
       For n = 0 To 6
        If TempKarteWert(n) <> Dreier And i>2
         i - 1
         Blatt + Pow(16,i)*TempKarteWert(n)
        EndIf 
       Next n
      EndIf
      If Blatt = 0
       If Paar
        Paar2 = 0
        For n = 0 To 5 :
         If TempKarteWert(n) = TempKarteWert(n+1) And TempKarteWert(n) <> Paar And TempKarteWert(n) > Paar2 :
          Paar2 = TempKarteWert(n)
         EndIf
        Next n
        ; zwei Paare
        If Paar2
         Blatt = $200000+Pow(16,4)*Paar+Pow(16,3)*Paar2
         For n = 0 To 6
          If TempKarteWert(n) <> Paar And TempKarteWert(n) <> Paar2
           Blatt + Pow(16,2)*TempKarteWert(n)
           n = 6
          EndIf 
         Next n
        ; ein Paare
        Else
         Blatt = $100000+Pow(16,4)*Paar
         i = 4
         For n = 0 To 6
          If TempKarteWert(n) <> Paar And i>1
           i - 1
           Blatt + Pow(16,i)*TempKarteWert(n)
          EndIf 
         Next n
        EndIf
       ; Höchste Karte
       Else
        Blatt = $000000
        i = 5
        For n = 0 To 6
         If TempKarteWert(n) <> Dreier And i>0
          i - 1
          Blatt + Pow(16,i)*TempKarteWert(n)
         EndIf 
        Next n
       EndIf
      EndIf
     EndIf
    EndIf
   EndIf
  EndIf
 EndIf
 ProcedureReturn Blatt
EndProcedure



Karte(0) = $21 ; Meine Karten
Karte(1) = $A2 ; Meine Karten
Karte(2) = $C3 ; Flop
Karte(3) = $23 ; Flop
Karte(4) = $33 ; Flop
Karte(5) = $E3 ; Turn
Karte(6) = $94 ; River

Debug Hex(BlattWertigkeit())

[NicknameFJ]

Stargate:

Da wird sich Sunny aber freuen. Du lieferst ihm ja den ganzen Code mit allen möglichen Bildern (Fullhouse, Straße Pärchen etc.) nicht nur die Möglichkeit den von ihm angefragten Straight Flush zu erkennen sondern sogarn noch eine Wertigkeit des Blattes.

Btw.: großartig gelöst


Grüße

NicknameFJ

[Sunny]

Erstmal Sorry, das ich mich so lange nicht mehr in meinem eigenen Thread mit eingemischt habe und ein BIG THANKS an STARGÅTE...
Ich hab mir das jetzt mal kurz angeschaut und den Code ein wenig überflogen. Auf den ersten Blick ein bischen unübersichtlich aber ansonsten sieht's auf jeden Fall richtig gut aus.
Ich werd den Code demnächst mal richtig durchforsten und gucken, wie ich ihn auf meine Bedürfnisse zuschneiden kann.

P.S.: auch ein liebes Dankeschön an alle anderen, für die kreativen Anreize.

Edit:
@STARGÅTE
Bei Straight's bzw. bei Straight Flush's liefert dein Code falsche Werte zurück. Aber dennoch ein super Ansatz.