Gehts praktischer? Thema:Verschiedene Instanzen einer Klasse

[dyn]

Hey.
Ich bin dabei ein Glücksrad-Spiel zu programmieren und habe unter anderem eine Spieler-Klasse mit gettern und settern für Kontostand, etc.
Nun muss ich in meiner Spielablauf-Klasse ständig if-Abfragen machen, um herauszufinden, wer gerade an der Reihe ist.
Gäbe es eine Möglichkeit, das so zu gestalten wie in einer normalen Spielerwechsel-Methode, indem ich irgendwie
ne variable aktuellerSpieler nehme und ihr dann das aktuelle Spieler-Objekt (s1, s2 oder s3) zuweise?
Diese variable müsste dann ja auch die Methoden der Spieler-instanz kennen...
Kennt jemand einen praktischeren Weg als den, den ich eingschlagen habe? Help pls

Beispiel der nervigen Abfragen, wer dran ist:

retVal = vokale.indexOf(letter);
		if (retVal > 0)
		{
		 	if (s1.istDran())
      		{
      			if (s1.getRundenKontostand() >= 300)
      			s1.setRundenKontostand(s1.getRundenKontostand()-300);
      			else
      			JOptionPane.showMessageDialog(this, "Sie haben nicht genug Geld, um einen Vokal zu kaufen!", "Armer Schlucker", JOptionPane.INFORMATION_MESSAGE);
      			naechster();
      		}
      	
      		else if (s2.istDran())
      		{
      		 	if (s2.getRundenKontostand() >= 300)
      			s2.setRundenKontostand(s2.getRundenKontostand()-300);
      			else
      			JOptionPane.showMessageDialog(this, "Sie haben nicht genug Geld, um einen Vokal zu kaufen!", "Armer Schlucker", JOptionPane.INFORMATION_MESSAGE);
      			naechster();	
      			
      	    }
      		
      		else if (s3.istDran())
      		{
      			if (s3.getRundenKontostand() >= 300)
      			s3.setRundenKontostand(s3.getRundenKontostand()-300);
      			else
      			JOptionPane.showMessageDialog(this, "Sie haben nicht genug Geld, um einen Vokal zu kaufen!", "Armer Schlucker", JOptionPane.INFORMATION_MESSAGE);
      			naechster();

Meine Spielerwechsel-Methode:

public void naechster()

     		{ 

            if (s1.istDran() == true)
            {
             s1.setIstDran(false);
           	 s2.setIstDran(true);
           	 dran.setText("Aktueller Spieler: 2");
            } 

           else if (s2.istDran() == true)  
           {
            s2.setIstDran(false);
           	s3.setIstDran(true);
           	dran.setText("Aktueller Spieler: 3");
           } 
           
           else if (s3.istDran() == true)  
           {
            s3.setIstDran(false);
           	s1.setIstDran(true);
           	dran.setText("Aktueller Spieler: 1");
           }

 

[SnooP]

Jetzt wirds knackig und wirklich OOP ... deine Aufgabenstellung eignet sich hervorragend dazu das ganze mal zu lernen ... - wie du erkennst, hast du da sehr viel redundanten Code der sich eigentlich nicht unterscheidet...

Wie wär's, wenn du die Spielsteuerung in den Spieler selbst verlagerst? Dann musst du nämlich überhaupt nicht mehr von außen analysieren, wer dran ist.. du machst das einfach so, dass du eine Klasse Spieltisch oder so hast, die das Glücksrad darstellt und die einzelnen Spielerobjekte. Ein Spieltisch hält per Liste mehrere Spielerobjekte (Methode addPlayer(Player p))... wenn das Spiel gestartet wird, geht das ganze in eine entsprechende Schleife (am Besten per Thread realisieren) und das erste Spielerobjekt wird aus der Liste genommen - am Ende angekommen muss natürlich wieder resetet werden... hier wäre ein Array und modulo auch noch ne schöne Alternative um wieder am Anfang anfangen zu können.
Wenn der jeweilige Spieler an der Reihe ist, führt er der Reihe nach seine Spielmöglichkeiten aus, z.B. dreheRad() etc... - falls du Computer und menschliche Spieler haben möchtest, kannst du hier sogar noch eine Oberklasse Player machen, die du in die Liste speicherst und dazu Unterklassen: HumanPlayer, ComputerPlayer, die die von der abstrakten Klasse vorgegebenen Methoden überschreiben. Bei ComputerPlayer macht der automatisch seine dreheRad() Methode - beim HumanPlayer kommt dann an der Stelle ne Benutzeraufforderung - dreh doch mal das Rad - und z.B. wie schnell er drehen soll ...

siehe: Denke in Objekten

 

[dyn]

danke für die schnelle antwort!
ich wäre dir noch dankbarer, wenn du das mit der addPlayer-methode, der Schleife und dem Thread etwas konkretisieren könntest.
Eventuell hätte ich diesen Thread lieber im Anfängerforum posten sollen ;/

 

[SnooP]

Also... das ganze ist eine 1:n Beziehung. 1 Spieltisch hält mehrere Spielerobjekte. Bei 1:1 Beziehungen ist das ganze recht einfach - ne Referenz zu der Klasse zu der die Beziehung besteht wird in die Klasse eingefügt. Bei 1:n geht das ja nu nich so einfach... ergo braucht man einen Datentyp, der mehr als nur ein Objekt halten kann. Dafür bieten sich Listen an, da diese grundsätzlich unendlich groß werden können (zumindest theoretisch). Ich schreibs einfach mal hin

public class Spieltisch {
   //Die Spieler die an dem Spieltisch "sitzen"
   private java.util.ArrayList spieler = new java.util.ArrayList();
   private boolean finished = false;  //Abbruchvariable - wenn Spiel beendet, dann true

   public void addSpieler(Spieler s) {
      this.spieler.add(s);
      anzSpieler++;   //Anzahl der Spieler evtl. interessant
   }

   public void run() {
      Iterator iter = spieler.iterator();
      while (!finished) {
          while (iter.hasNext()) {
             Spieler aktSpieler = (Spieler) iter.next(); //next() gibt immer Object zurück - daher casten
             System.out.println(aktSpieler.getName()+" ist am Zug");
             aktSpieler.dreheRad();
             if (aktSpieler.hatGewonnen()) {
                this.finished = true;
                return;  //einfach abbrechen
           }
           iter = spieler.iterator()   //iterator neu besorgen, weil am Ende angekommen.... (mit Modulo wäre das nicht passiert ;) )
       }
    }

//... weitere Methoden

}

public class Spieler {
   private String name;   //getter dazu...
   //...
  public void dreheRad() {
     //Hier Benutzereingabe - "Rad drehen?" - wie stark (1-10) oder sowas..." ;)
  }
//...
}

Ich hoffe das ist jetzt etwas deutlicher geworden. Die Sache mit den Threads ist erstmal dann nicht erforderlich, wenn sowieso nur menschliche Spieler spielen und die Benutzerabfrage halt gestellt wird... Threads werden dann sinnvoll, wenn man während des Spiels, das Programm auchmal andere Aktionen zulassen möchte... angenommen z.B. das nur Computerspieler spielen, wären die in der Endlosschleife (!finished) solange gefangen, bis irgendwer gewonnen hat... das kann evtl. wahnsinnig lange dauern oder ganz schnell gehen und man sieht vom Spiel nichts mehr ... dann hat man mithilfe eines Threads die möglichkeit Pausen in den einzelnen Schritten einzulegen. Aber das würde ich mir mal in Ruhe zu einem anderen Zeitpunkt angucken... erstmal solltest du das OOP verstanden haben.[/code]