[Stuff][AS2] Poker Blatt Klasse

[Circushund]

Hiho Leute,

So, ich hab neulich mal angefangen, ein Poker Kartenspiel in Flash zu basteln und hab dabei eine eigene Klasse gebaut.
Da mir hier ja immer so nett geholfen wird *hust hust, dachte ich mir, geb ich auch mal was zurück und dachte mir, den Code zu posten.
Die Klasse hat drei Funktionen, einmal:

a) Blatt, zum Auswerten der 5 Karten auf der Hand
b) durchmischen, zum Mischen eines Arrays aus 32 Karten
c) zieheKarte zieht eine Karte (von 32) und gibt deren Farbe und Wert zurück

a)
Die Blatt - Funktion braucht ein Array im Format
Karte [n][Farbe,Wert]
Wobei für Farbe folgende Werte gültig sind:
"E" Eckstein( Karo)
"H" Herz
"P" Pik
"K" Kreuz

Und für Wert:
"A" Ass, "K" König, "D" Dame, "B" Bube, "1" Zehn, "9" Neun, "8" Acht und "7" Sieben
Bspl.:

PHP-Code:

var Hand:Array=new Array();
Hand[0] = ["H","K"];
Hand[1] = ["K","9"];
Hand[2] = ["H","9"];
Hand[3] = ["P","9"];
Hand[4] = ["E","9"];

trace( Pokerkarten.Blatt( Hand )); //Ausgabe 8,Vierling,100 


Die Rückgabe: Array
Stufe , Blatt , Kickerwert

Wobei die Stufe von 1 =Höchste Karte bis 10 = Royal Flash reicht.
Blatt gibt an was es ist: zb. "1 Paar", "2 Paar" usw.
Der Kickerwert gibt die höchste Karte an und gilt als 2.ter Vergleich, falls zwei Blätter die Gleiche Stufen haben.

b)
Die Funktion durchmischen mischt einfach ein Array von 32 Karten
Beispl.

PHP-Code:

var Deck : Array = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31];
        trace( Pokerkarten.durchmischen(Deck) ); // Ausgabe: 2,18,6,28,24,30... 


Mit der letzten Funktion lässt sich eine Karte ziehen:

PHP-Code:

trace( Pokerkarten.zieheKarte(29) ); // Ausgabe E,9 = enspricht Karo 9 


So, und nun die Ganze Klasse:

PHP-Code:

class Pokerkarten {
    
      
    
    
    ///////////////////////////////////////////
    //
    // Auswertung der Hand (5 Karten )
    //
    ///////////////////////////////////////////
      public static function Blatt( Hand : Array ):Array {
        
     
     var addierteWerte : Number=0;
     var addierteFarben : Number=0;
     var Stufe : Number = 0;
     
     var Wert : Array = new Array();
     var Farbe : Array = new Array();
     var kWert : Array = ["7","8","9","1","B","D","K","A"];
     
     var AufHand : String = "";
      
      Wert["A"]=10000000;
      Wert["K"]=1000000;
      Wert["D"]=100000;
      Wert["B"]=10000;
      Wert["1"]=1000;
      Wert["9"]=100;
      Wert["8"]=10;
      Wert["7"]=1;
      
      Farbe["E"]=1000; // Eckstein(Karo) ist die stärkst Farbe
      Farbe["H"]=100;
      Farbe["P"]=10;
      Farbe["K"]=1;    //Kreuz ist die schwächste Farbe
      
      //Aufsummieren
        
        for(var i=0; i < Hand.length ; i++){
          var farb = Hand[i][0];
          var wert = Hand[i][1];
          addierteFarben+= Farbe[farb];
          addierteWerte += Wert[wert];
          }
             
     
     var kickerwert : Number = 0;
     
     // HÖCHSTE KARTE
     
     // Höchste Karte = kickerwert
     // Farbe wird baeachtet!!
     
     AufHand = "Höchste Karte"
         kickerwert = (addierteWerte + addierteFarben)
        Stufe = 1;
     
     // FLASH ( alles eine Farbe )
     
     // Höchste Karte = kickerwert
     // Farbe wird baeachtet!!    
        
        if((addierteFarben == 5    ) || 
            (addierteFarben == 50   ) ||
            (addierteFarben == 500  ) ||
            (addierteFarben == 5000 )){     
          
          AufHand = "Flash"
           kickerwert = (addierteWerte + addierteFarben) 
           Stufe = 6;
         }     
     
     // 1 PAAR, 2 PAAR, DRILLING, FULL HOUS, VIERLING
     
     // Der Kickerwert ist jeweils die Höchste Karte der
     // Kombination ( Paar, Drilling ect.)
     
     var strWerte : String = String(addierteWerte);
     var suche : String = ""; 
     var tmp : Number = 0;
       for (var i:Number = 0; i < strWerte.length; i++) {
        
        if((strWerte.charAt(i) == "2") || (strWerte.charAt(i) == "3")
                                       || (strWerte.charAt(i) == "4")){
          suche += strWerte.charAt(i);
          tmp = Math.max(Wert[kWert[(strWerte.length-i)-1]],tmp);
          kickerwert = tmp;
          }
        }
             switch (suche){
                 case  "2": 
                  AufHand = "1 Paar" ;              
                   Stufe = 2;break;
                 
                 case "22":
                  AufHand = "2 Paar" ; 
                   Stufe = 3;break;
                 
                 case  "3": 
                  AufHand = "Drilling" ; 
                   Stufe = 4;break;
                   
                 case "23":
                 case "32":
                  AufHand = "Full House"; 
                   Stufe = 7;break;
                 
                 case  "4":
                  AufHand = "Vierling";
                   Stufe = 8; break;
             }
     
     
     // STRASS, STRAIT FLUSH, ROYAL FLUSH
     
     // Höchste Karte = kickerwert
     // Farbe wird nicht beachtet !!
     
     if((addierteWerte == 11111000)||
        (addierteWerte == 1111100 )||
        (addierteWerte == 111110  )||
        (addierteWerte == 11111   )){

              AufHand = "Strasse"
              kickerwert = addierteWerte;
              Stufe = 5;
         
         if((addierteFarben == 5    ) || 
            (addierteFarben == 50   ) ||
            (addierteFarben == 500  ) ||
            (addierteFarben == 5000 )){
              
              if(addierteWerte == 11111000){
              AufHand = "Royal Flash"
               Stufe = 10;
             }else{
              AufHand = "Strait Flash"}
               Stufe = 9;
            }
         
      }
     
     
                
        return [ Stufe, AufHand, kickerwert ];
    
    
    }
    
    ///////////////////////////////////////////
    //
    //  Kartendeck durchmischen und         
    //  ein Array zurückgeben
    //
    ///////////////////////////////////////////
    public static function durchmischen(Deck : Array ):Array{
        
        var rndTemp = new Array();
        var temp    = new Array();
        
        for ( var i:Number = 0; i < Deck.length; i++ ) {
            rndTemp[i] = i;
        }
        
            for (var i:Number = 0 ; i < Deck.length; i++ ) {
                var pos = Math.floor(Math.random() * ( rndTemp.length - .01 ) );
                temp[i] = Deck [ rndTemp[ pos]];
                rndTemp.splice(pos, 1);
            }
        
            for (var i:Number = 0; i < Deck.length; i++ ) {
                Deck[ i] = temp[ i];
            }
        
    
        return Deck;
        
    }

    
    ///////////////////////////////////////////
    //
    //  Eine bestimmte Karte ziehen,
    //  Rückgabe, Array( Farbe, Wert ) 
    //
    ///////////////////////////////////////////
    public static function zieheKarte(Nr : Number) : Array{
         
         var Farbe : Array = ["K","P","H","E"];
         var Wert : Array = ["A","K","D","B","1","9","8","7"];
         var Karten : Array = new Array();
        
        //Farben und Karten zuordnen
        for (var i=0; i<4; i++){
          for (var ii=0; ii<8; ii++){
            Karten.push([Farbe[ i],Wert[ ii]]);
            //trace(Satz[Satz.length-1]);
            }
        }
    
      return Karten[ Nr];
    
    
    }
    
    
        
} 


So, und nun viel Spass damit, falls jemnd undichte Stellen findet oder eine elegantere performantere Methode findet, würd mich freuen was zu hören.
Eine Schwachstelle die mir auffällt ist, das der Kickerwert nur ein pseudo-Wert darstellt, wo sich zwar der Wer, nicht aber die Farbe ableiten lässt bzw. hab ich es noch nicht hinbekommen .
Die zugrundegelegten Regeln sind von Wikipedia Suche:"Poker"

[Omega Psi]

Ich würde das gleich ganz anders aufziehen:

• Klasse Deck: enthält alle Karten, und Funktionen wie mischen()
• Klasse Karte: Jede Karte existierte nur einmal, hat einen Namen, Wert und eine Farbe -> eine ID ist auch zusätzlich sehr gut, die wird auf- oder absteigend vergeben.
• Klasse Spieler: jeder Spieler kann eine bestimmte Anzahl von Karten haben
  • die Karten kann er auch einaml tauschen
  und besitzt Geld
  • das Geld kann er setzen
• Klasse Geber: der Geber mischt das Deck, verteilt die Karten und tauscht sie einmal. Ausserdem enthält der Geber die KI, da er das Spiel steuert in Abhängigkeit von den Entscheidungen der Spieler.
• Klasse Varianten: Jede Variante hat verschiedene Regeln. Die Klasse Varianten dient nur dazu, die verschiedenen Varianten zu wrappen, um auf diese modular zugreigen zu können.
• Klasse Variante: Jede Variante hat eigene Regeln, nach denen ein Geber den Spielfluss kontrolliert.

[sebastian]

Die Idee mit den Werten finde ich gut. Würde es je nach Anwendung trotzdem
etwas anders aufziehen.

Was ist das eigentlich für eine Variante? Vorallem die 32 Karten wundern mich

[Circushund]

@ Omega Psi,

Wenn man ein ganzes Spiel draus machen will, ist es natürlich auch gut, mehere Klasen mit einzubinden. Diese Klasse soll eigentlich nur die Auswertung der Karten nach den Pokeregeln geben , mehr nicht.
Und natürlich, bei einem ganzen Spiel kommt noch einiges mehr hinzu.

@ Ich hab das standart Skatblatt (32) Karten genommen. Man kann es aber einfach ausbauen, indem man bei den Werten noch die "2"-"3"-"4" ect. anhängt. Da ich ein Spiel für nur 3 Spieler mache, sind 32 Karten ausreichend, zumal man eh nur 1x tauscht was insgesammt 5+5+5=15 +maximal 4+4+4 getauschte =12 macht 24 Karten, die benutzt werden.

[sebastian]

Skat und Poker ist aber nicht das gleiche...

[Omega Psi]

Ich dachte, es ist schon ein Spiel?

[Janoscharlipp]

Coole Sache, kürzlich schonmal drüber nachgedacht, und bin ganz schön ins Grübeln gekommen Thx!

[shorty]

Circushund, schönes Ding! Danke!

... wenn Du möchtest, klemm ich [stuff] davor, und verschiebe es in den gleichnamigen Bereich?!


lg,
shorty

[Circushund]

@ shorty,

wenn du magst verschiebs in den passenden Bereich, ich wußt nicht wo ichs hinpacken sollte.

[bokel]

Das schreit ja eigentlich mal wieder nach einem Wettbewerb, in dem Bots gegeneinander Pokern. Hat irgendjemand Interesse?

[shorty]

@Circushund: done

@bokel: Ich habe von Poker so viel Ahnung wie ne Kuh vom Stricken. Vieleicht jemand anders, oder ein gänzlich anderer Wettbewerb / anderes Thema? Nun gut, dieser Fred ist dafür nicht der richtige Platz. Mach doch mal einen auf, dann schaun mer a mal wer sich da so einfindet.


lg,
shorty

[Janoscharlipp]

Ich wäre dabei , allerdings erst in ein zwei Wochen!

[sebastian]

Zitat von bokel

Das schreit ja eigentlich mal wieder nach einem Wettbewerb, in dem Bots gegeneinander Pokern. Hat irgendjemand Interesse?

Streng genommen können Bots über das Internet besser spielen als Menschen,
weil sie streng mathematisch vorgehen können. Viel interessanter wäre es
wer einen Bot mit der größtmöglichen Ausbeute schreiben kann..

greetz

[Circushund]

@bokel,

ja interessant dein 4 Gewinnt, doch hab ichs noch nicht richtig verstanden?
Du sendest da mittel .send Daten zwischen .swf's hin und her ? Und versuchst wohl so die KI von deinem "main"-code oderso zu kapseln bzw. das alles Modular aufzubauen ?

[bokel]

Wir bauen hier einen optimalen Bot und dann lassen wir den überall mitspielen und kassieren ab

@Circushund: Ja genau. Ich weiss auch nicht mehr, wieso ich das damals per LocalConnection gemacht hatte. Die KIs könnte man wohl auch direkt ansprechen.