# Für jedes Objekt ein Thread (Poker)



## Maurice (16. Dez 2010)

Hallo, ich habe ein kleines Problemchen
.
Wir haben in der Schule die Aufgabenstellung ein eigenes Projekt zu erstellen... Ich habe mir vorgenommen ein Netzwerk Poker zu programmieren. Die Klassen sind fertig und getestet. Jetzt möchte ich natürlich eine kleine TestUI schreiben. Ich habe nun das Problem und weiß nicht so recht wie ich zu jedem Client an dem Pokertisch seine Karten zu schiken soll. Habe mit meiner Lehrerin gesprochen und sie meint ich soll eine Spielbank erstellen wo ich jedem Spielmaster (mein Dealer objekt) in einem extra Thread öffne, wo jeder sich mit verbindet. Nun weiß ich nciht so recht wie ich das realisieren soll wie jeder sich an diesem bestimmten Tisch also dem bestimmten Thread anmeldet und da seine Karten (Objekte) zurück geschikt bekommt?

Ich hatte mir das selber anders gedacht, nämlich das man, der der den Server erstellt, den Dealer erzeugen muss. Der Client erzeugt sein Spieler objelkt und wenn er sich mit dem Dealer verbinden will, schikt er dem Dealer seine Spieler Referenz zu. Der Dealer teilt dann die Karten aus. Gibt also jedem Spieler objekt was er kennt Karten. Sobalt ein Spielerobjeklt Karten hat schikt es die Karten an sein Client zurück.

Was denkt ihr. Habt ihr Ideen wie ich es machen könnte, ich stehe sehr auf dem Schlauch und habe schon vieles versucht. 

Wenn ihr Fragen ahbt oder so einfach melden. Bin um jede Idee froh.

Achso, ich wollte das mit Socket realisieren, habe auch schon viel hier über RMI? gelesen, was denkt ihr was ist besser geeignet..?

Vielen dank schoneinmal 
Maurice


----------



## VfL_Freak (16. Dez 2010)

Moin,

offen gestanden habe ich nicht wirklich verstanden, was Du tun möchtest!
Poste mal den Code (Code-Tags ! ), vlt. wird es dann klarer ..... 

gruß
Klaus


----------



## Maurice (16. Dez 2010)

Ok.. ja ich wusste auch nicht so ganz wie ich mein Problem in Worte fassen soll.

Also ich möchte irgendwie von meinem Dealer Objekt der die Poker Karten an die Spieler gibt die auf die Oberfläche angezeigt bekommen. Also heißt, ich öffne das Programm und wähle ein Spieltisch aus. Dann shikt meine Oberfläche dem Tisch also dem Dealer meine Spieler daten. Jetzt komme ich von dem Dealer Karten und diese Karten möchte ich dann auf meiner Oberfläche angezeigt bekommen. Das alles findet im Netzwerk statt und wie kann ich das am besten Realisieren das der bestimmte Client seine Karten aber auch nur seine Karten angezeigt bekommt. 

Also es geht um die kommunikation.

Karten Objekt was an die Ui soll

```
public class Karte {

  // Anfang Attribute

  
  private String farbe;
  private String typ;
  private String zahl;
  private int wert;

  private boolean vorhanden;
  // Ende Attribute

  // Anfang Methoden
  public Karte(String farbe, String typ, String zahl,int wert, boolean vorhanden){
     this.farbe=farbe;
     this.typ=typ;
     this.zahl=zahl;
     this.vorhanden=vorhanden;
     this.wert=wert;
   }
   
  public String toString(){
    return farbe+" "+typ+" "+zahl;
  }
  
  public int getWert(){
    return wert;
  }
  
  public String getTyp(){
    return typ;
  }

  public boolean getVorhanden() {
    return vorhanden;
  }

  public void setVorhanden(boolean vorhanden) {
    this.vorhanden = vorhanden;
  }

  // Ende Methoden
}
```

Dealer also der SPielmaste

```
public class Dealer extends Regeln{

  // Anfang Attribute
  private ArrayList <Spieler> alleSpieler = new ArrayList<Spieler>(); //ist auch die sitzreihenfolge.
  private Karte mitteKarten[] = new Karte[5];

  private static int z=0;
  private Deck d;
  private double pot;
  private Spieler [] winners;
  private Spieler winner;
  private Spieler [] sp;
  private String ausg="";
  private Karte ka [];
  private int id;
  // Ende Attribute

  public Dealer(int id) {
    d = new Deck();
    d.setze();
    this.id=id;
  }

  // Anfang Methoden
  
  public void newSitz(Spieler sp, int index){
    alleSpieler.add(index,sp);
  }
  
  public void neuesSpiel(){
    z=0;
    pot=0.0;
    ausg="";
    winner=null;
    winners=null;
    ka=null;
    
    for(int i =0;i<52;i++){
      d.setVorhanden(i);
    }
  }
  
  public Spieler[] ermittleSieger(){
    winners = new Spieler[alleSpieler.size()];
    sp = new Spieler[alleSpielerLength()];
    for(int i=0;i<alleSpielerLength();i++){
      sp[i]=getSpieler(i);
    }

     winners=pRoyalFlush(mitteKarten,sp);
     if(getWinnersS()>=1){
       return winners;
     }else{
        winners=pStraightFlush(mitteKarten,sp);
        if(getWinnersS()>=1){
          return winners;
        }else{
           winners=pVierling(mitteKarten,sp);
           if(getWinnersS()>=1){
             return winners;
           }else{
              winners=pFullHouse(mitteKarten,sp);
              if(getWinnersS()>=1){
                 return winners;
              }else{
                winners=pFlush(mitteKarten,sp);
                if(getWinnersS()>=1){
                   return winners;
                 }else{
                    winners=pStraight(mitteKarten,sp);
                    if(getWinnersS()>=1){
                       return winners;
                    }else{
                       winners=pThreeOfAKind(mitteKarten,sp);
                       if(getWinnersS()>=1){
                         return winners;
                       }else{
                         winners=pTwoPair(mitteKarten,sp);
                          if(getWinnersS()>=1){
                            return winners;
                          }else{
                             winners=pOnePair(mitteKarten,sp);
                             if(getWinnersS()>=1){
                                return winners;
                             }else{
                                winners=pHighCard(sp);
                                if(getWinnersS()>=1){
                                   return winners;
                                }else{
                                  System.out.println("Keiner hat gewonnen Fehler!");
                                }
                             }
                          }
                       }
                    }
                 }
              }
           }
        }
     }
    return winners;

....
   }
  }
```


```
public class Spieler {

  // Anfang Attribute
  private String nickName;
  private int spielerNr;
  private double gesamtGuthaben;
  private double gesetzteChips;
  private boolean willKarten=true;
  private Karte [] karten = new Karte[2];
  private boolean spielt;  //Wenn man am Spielen in einer Runde ist
  // Ende Attribute

  // Anfang Methoden
  public void setzen (double betrag){
    gesetzteChips+=betrag;
  }
}
```

Diese Karten in Spieler möchte ich egrne an meine UI geschikt bekommen. ODer wer kommuniziert mit wem?...


----------



## Marco13 (16. Dez 2010)

Mal ganz allgemein: Da kommt nichts drin vor, was mit Netzwerken zu tun hat? Hast du schonmal sowas wie Writing the Server Side of a Socket (The Java™ Tutorials > Custom Networking > All About Sockets) durchgearbeitet (siehe auch ganz unten, bei "Multiple Clients") ?


----------



## Maurice (17. Dez 2010)

Naja ich mochte die karten des Spielers haben. aber vielen dank für den Link. Da werde ich mich noch mehr einlesen.


----------

