Erste Schritte Methoden im Wechselspiel durch zwei Objekte aufrufen

[Kackfohgel]

Hallo,

ich versuche mir gerade selbst ein wenig Java beizubringen. Vorkenntnisse in (objektorientierten) Programmiersprachen habe ich keine.

Um die Motivation nicht zu verlieren, versuche ich mich neben der Aneignung von theoretischem Wissen immer mal wieder an kleineren Übungen.

Aktuell ein kleines Programm, welches aus zwei Klassen Test.java und Testspieler.java besteht (verzeiht mir bitte, dass ich die Klassen jetzt groß geschrieben habe, ich wollte nur schnell ein Beispiel erstellen und das ist mir erst danach aufgefallen).

Ziel des Programms ist es, dass die beiden Spielerobjekte sp1 und sp2 solange spielen, bis einer der beiden den Ball 10 Zeiteinheiten hatte.

Dafür habe ich jetzt mehrere Ansätze, die ich jedoch alle nicht weiß programmtechnisch umzusetzen. Aber zunächst mal der bisherige Code meiner beiden Klassen:


Test.java

public class Test {
	
	public static void main(String[] args) {
	
		// Zwei Objekte der Klasse Spieler erstellen
		Testspieler sp1 = new Testspieler("Anton");
		Testspieler sp2 = new Testspieler("Boris");
		// Spieler 1 den Ball geben
		sp1.hatBall = true;
		
		while(sp1.hatBall && sp1.dauer < 10){
				sp1.spielen();
			}
			// Wenn Spieler 1 den Ball abgegeben hat, soll Spieler 2 solange weiterspielen
			// bis er wiederrum den Ball abgibt.
			// Das funktioniert noch so weit, aber mein Gefühl sagt mir, dass diese Lösung
			// schon unsauber ist
			sp2.hatBall = true;
			while(sp2.hatBall && sp2.dauer < 10){
				sp2.spielen();			
			}
			// sp1.hatBall = true;
			// Hier soll jetzt Spieler 1 wieder spielen, wenn Spieler 2 den Ball abgibt;
			// es soll also quasi wieder zu "while(sp1.hatBall)" gesprungen werden und
			// so lange weiter gespielt werden, bis einer der Spieler 10 Zeiteinheiten am Ball war.
		}
}

Testspieler.java

import javax.swing.JOptionPane;


public class Testspieler {
	
	// Attribute
	String name = "Nobody";
	boolean hatBall = false;
	int dauer = 0;
		
	// Konstruktor
	Testspieler(String name)
	{
		this.name = name;
	}
	
	// Methoden
	public void spielen() {
		int benutzereingabe;
		benutzereingabe = 	JOptionPane.showConfirmDialog(null, "Willst du den Ball behalten?",
							"Weiter?", JOptionPane.YES_NO_OPTION);
		if(benutzereingabe == 1)
		{
			abgeben();
		} else {
			dauer += 1;
			System.out.println(name + " behält den Ball. (Dauer: " + dauer + ")");
		}
	}
	
	public void abgeben() {
		System.out.println(name + " gibt den Ball ab.");
		hatBall = false;
	}
}

Meine theoretischen Ansätze (sortiert in der Reihenfolge, wie sie mir am sinnvollsten erscheinen):

1. Die while-Schleife wird nur einmal in Test.java eingebaut und jeweils für das Objekt (den Spieler) aufgerufen, der den Ball hat (hatBall == true) ist. Nach einem Wechsel des aktiven Spielers, muss die while-Schleife erneut aufgerufen werden, für den jetzt aktiven Spieler usw.
2. Nachdem Spieler 2 den Ball abgegeben hat, setze ich eine "Sprungmarke" oder Ähnliches, dass er wieder bei

   while(sp1.hatBall ...

   weitermacht.
3. Ich schreibe die

   while(sp1.hat Ball ...

   und

   while(sp2.hat Ball ...

   so oft untereinander, bis zwangsläufig, einer von beiden den Ball mind. 10 ZE gehabt haben müsste und die Bedingung nicht mehr erfüllt ist. Das ist zugleich die einzige Möglichkeit, die ich praktisch umzusetzen wüsste, welche mir aber gleichzeitig am unpraktikabelsten erscheint. Kaum auszudenken, wenn die mal 100 ZE oder mehr spielen sollen ;-)

Ich hoffe, ihr könnt mir zu Ansatz 1. und 2. ein paar Lösungsansätze geben.(?)

Freundliche Grüße
Kackfohgel

 

[kaetzacoatl]

Pack beide schleifen einfach in eine dritte.
die Bedingung wäre dann

sp1.dauer < 10 && sp2.dauer < 10

 

[Bile Demon]

Aktuell ein kleines Programm, welches aus zwei Klassen Test.java und Testspieler.java besteht (verzeiht mir bitte, dass ich die Klassen jetzt groß geschrieben habe, ich wollte nur schnell ein Beispiel erstellen und das ist mir erst danach aufgefallen).

Was genau ist dir denn aufgefallen? Stimmt doch so wie es ist.

 

[Kackfohgel]

Pack beide schleifen einfach in eine dritte.
die Bedingung wäre dann

sp1.dauer < 10 && sp2.dauer < 10

Manchmal kann es doch so einfach sein - jetzt wo ich das lese, schäme ich mich schon fast, dass ich da nicht drauf gekommen bin, aber genau das war es.

Vielen Dank dafür

@Bile Demon: Mit den Klassennamen hast du natürlich auch recht, ich war beim Erstellen des Threads ein bißchen durcheinander und habe die Konventionen für Klassen und Variablen vertauscht. Also Klassen groß und Methoden klein, Klassen groß, Methoden klein ...

 

[hüteüberhüte]

Du kannst das ganze auch ganz ohne OOP lösen:

    public static void main(String[] args) {
        boolean aSpielt = Math.random() < 0.5;
        int dauer = 0;
        Random r = new Random();

        while (dauer < 10) {
            if (r.nextInt(3) == 0) {
                aSpielt = !aSpielt;
                dauer = 0;
            }
            dauer++;
            System.out.println((aSpielt ? "A" : "B") + " spielt. Dauer " + dauer + ".");
        }
    }

 

[bone2]

ach hüte, dann besser nix sagen...

er will objekte, du schlägst ne lösung ohne vor, nachdem er sein problem schon gelöst hat

 

[hüteüberhüte]

Vorkenntnisse in (objektorientierten) Programmiersprachen habe ich keine.

Dann ist es doch einfacher, erst mal mit imperativen Sprachkonzepten anzufangen...: Galileo Computing :: Java ist auch eine Insel - 2 Imperative Sprachkonzepte

Ich klettere ja auch nicht auf den Mount Everest, wenn ich gerade erst mit der Kletterwand angefangen habe...

 

[Kackfohgel]

Vielen Dank für den alternativen Lösungsweg, auch wenn ich hier bewusst eine objektorientierte Ansatz gewählt habe, da ich auch mit Java angefangen habe, um das objektorientierte Denken zu lernen.

 

[Kackfohgel]

Das kleine Beispielprogramm erscheint mir irgendwie noch ziemlich sinnlos. Richtig sinnvoll wird es aber, wenn die Spieler den Ball ein paar Sekunden halten dürfen, bevor sie gefragt werden, ob sie ihn wieder abgeben wollen. Ich sehe mich schon auf Platz 1 der Spielecharts, wenn ich das umgesetzt bekomme :hihi:

Jetzt habe ich mal nach "Java Pause" gesucht und bin auf so spannende Dinge wie Threads gestoßen, die in meinem Buch "Programmieren lernen mit Java" (Habelitz) erst auf den letzten Seiten erklärt werden und die ich jetzt noch nicht verstehe. Ich will ja auch garnicht mehrere Unterprogramme gleichzeitig laufen lassen oder Ähnliches, sondern nur die Methode spielen(); mit einer kurzen Pause beginnen lassen.

Hier die Methode, die mit einer Pause beginnen soll

public void spielen() {
        // Kurze Pause, bevor die Frage kommt
        // Das läuft nicht (bricht das Programm immer ab):
        // while(true){try {Thread.sleep(2000); } catch(InterruptedException e) { break; }}
        int benutzereingabe;
        benutzereingabe =   JOptionPane.showConfirmDialog(null, "Willst du den Ball behalten?",
                            "Weiter?", JOptionPane.YES_NO_OPTION);
        if(benutzereingabe == 1)
        {
            abgeben();
        } else {
            dauer += 1;
            System.out.println(name + " behält den Ball. (Dauer: " + dauer + ")");
        }
    }

Die auskommentierte (nicht funktionierende) while-Schleife ist nur eine Gedächtnisstütze für mich; da hab ich einfach Quellcode kopiert

Muss ich jetzt warten, bis ich bei dem Threads-Themen gelandet bin und diese verstehe oder gibt es einfachere Methoden für einen kurze Pause im Programm in dem obigen Beispiel?

Freundliche Grüße
Kackfohgel

 

[hüteüberhüte]

Thread.sleep(2000); ist schon richtig. Mehrere Thread benötigst du nur, wenn etwas gleichzeitig geschehen soll

Btw. Eine kleine Spielerei von gestern:

import java.util.Observable;
import java.util.Random;

public class SpielerFuss extends Observable {

    public static final int amBall = 0;
    public static final int nichtAmBall = 1;
    public static final int schiesstTor = 2;
    public static final int verliertBall = 3;
    private static final Random rand = new Random();
    private int status;

    public SpielerFuss(int status) {
        this.status = status;
    }

    public void spiele() {
        if (status == amBall) {
            if (rand.nextInt(3) == 0) { // 33 %
                status = verliertBall;
            } else if (rand.nextInt(100) == 0) { // 1 %
                status = schiesstTor;
            } else {
                // status = amBall;
            }
        } else if (rand.nextInt(SpielerObserver.anzahl) == 0) { // 1/SpielerObserver.anzahl
            status = amBall;
        } else {
            status = nichtAmBall;
        }
        setChanged();
        notifyObservers(status);
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

public class SpielerObserver implements Observer {

    public static final int anzahl = 11;
    private final List<SpielerFuss> spieler = new ArrayList<SpielerFuss>(anzahl);
    private int runde = 0;

    public SpielerObserver() {
        for (int i = 0; i < anzahl; i++) {
            SpielerFuss sp = new SpielerFuss(SpielerFuss.nichtAmBall);
            sp.addObserver(this);
            spieler.add(sp);
        }
        Collections.shuffle(spieler);
        spieler.get(0).spiele();
    }

    @Override
    public void update(Observable o, Object arg) {
        synchronized (this) {
            if (++runde > 1000) {
                return;
            }
        }
        SpielerFuss sp = (SpielerFuss) o;
        int status = (int) arg;
        switch (status) {
            case SpielerFuss.amBall:
                System.out.println(sp + " ist am Ball.");
                sp.spiele();
                break;
            case SpielerFuss.nichtAmBall:
                spieler.get(runde % anzahl).spiele();
                break;
            case SpielerFuss.schiesstTor:
                System.out.println(sp + " schiesst Tor.");
                spieler.get(runde % anzahl).spiele();
                break;
            case SpielerFuss.verliertBall:
                System.out.println(sp + " verliert den Ball.");
                spieler.get(runde % anzahl).spiele();
                break;
        }
    }

    public static void main(String[] args) {
        new SpielerObserver();
    }
}

 

[bone2]

Thread.sleep(2000)

legt immer den aktuellen Thread schlafen. Auch dein einzelnes main programm ist ja ein Thread (wenn auch noch ein einsamer).

kannst dir nur schonmal merken, das du damit nicht andere threads schlafen legen kannst.


edit: @Hütes Beispiel: aua, logik im konstruktor. sowas sollte man tunlichst vermeiden.

 

[hüteüberhüte]

edit: @Hütes Beispiel: aua, logik im konstruktor. sowas sollte man tunlichst vermeiden.

Du meinst

spieler.get(0).spiele();

? In diesem Fall nicht nötig, dafür extra eine Methode

 

[bone2]

meinte eher

    public SpielerObserver() {
        for (int i = 0; i < anzahl; i++) {
            SpielerFuss sp = new SpielerFuss(SpielerFuss.nichtAmBall);
            sp.addObserver(this);
            spieler.add(sp);
        }
        Collections.shuffle(spieler);
        spieler.get(0).spiele();
    }

das gehört in eine eigene methode zb run() init() was auch immer, nicht in den konstruktor

 

[Kackfohgel]

Also das Beispiel von Hüte muss ich mir in aller Ruhe nochmal zu Gemüte führen, scheint ein ernster Konkurrent für meine Spieleidee zu werden

Aber nochmal zur Pause und vlt. auch für andere mit ähnlicher Problemstellung (weil ich das etwas kniffelig fand mit dem try und catch):

Thread.sleep(2000);

allein gibt mir einen Fehler aus Unhandled exception type InterruptedException. Er verlangt also scheinbar nach einer Fehlerbehandlung. Deshalb habe ich das ganze in ein try- und catch-block gepackt und der Übersicht halber dies in einer Funktion

pausieren();

untergebracht.

public void pausieren() {
		try  { Thread.sleep(2000); }
		catch(InterruptedException e) { }
}

public void spielen() {
        pausieren();
        int benutzereingabe;
        benutzereingabe =   JOptionPane.showConfirmDialog(null, "Willst du den Ball behalten?",
                            "Weiter?", JOptionPane.YES_NO_OPTION);
        if(benutzereingabe == 1)
        {
            abgeben();
        } else {
            dauer += 1;
            System.out.println(name + " behält den Ball. (Dauer: " + dauer + ")");
        }
    }

So funktioniert es erstmal, jetzt muss ich nur noch einen spannenden Spieletitel finden

Vielen Dank an bone2 und hüteüberhüte für die Hilfe

 

[bone2]

Die

InterruptedException

ist eine der wenigen und gleichzeitig die wohl die meist geschluckte exception (

catch(InterruptedException e) {}

). Das throws ist aber nötig, damit man eine Chance hat herrauszufinden, ob die sleep zeit durchgekaufen ist oder durch irgendwas unterbrochen wurde.
Interessiert aber in 999 von 1000 Fällen niemanden.

 

[hüteüberhüte]

@bone2: Wie gesagt, es gehört zur Objektinitialisierung. Deshalb nicht fehl am Platze.

InterruptedException behandeln ist unnötig, wenn dadurch der Programmablauf nicht beeinflusst wird.

catch (SomeException ignore) { }

ist durchaus üblich:

Another example where exceptions are typically ignored is in calls to sleep.

try {
    Thread.sleep(DELAY);
} catch (InterruptedException ignoredException) {
    // Silently ignore.  This thread can never cause an exception.
}

Java: Exception Usage

 

[jgh]

imho sollte man nichtsdestotrotz immer die Exception ausgeben lassen...ob nun als simple System.out, oder per Logger...aber leer, ne das ist kein feiner Stil.

 

[bone2]

@bone2: Wie gesagt, es gehört zur Objektinitialisierung. Deshalb nicht fehl am Platze.

InterruptedException behandeln ist unnötig, wenn dadurch der Programmablauf nicht beeinflusst wird.

catch (SomeException ignore) { }

ist durchaus üblich:

Nur das es zur Initialisierung gehört, rechtfertigt nicht den Aufenthalt im Konstruktor. Das ganze wird untestbar, undurchsichtig.
How to Write Clean, Testable Code - YouTube

Die InterruptedException beim Sleep ist die einzige Exception, bei der es üblich ist, sie komplett, kommentarlos zu ignorieren. Bei jeder anderen ist es, wie schon mehrfach gesagt, schlechter Stil. Sowas garnicht erst angewöhnen.

 

[Kackfohgel]

Hallo nochmal,

nachdem ich durch hüte ernsthafte Konkurrenz für mein Ball-halten-Spiel bekommen habe, dachte ich mir ihn nun durch eine grafische Benutzeroberfläche aus dem Rennen zu nehmen

Naja und jetzt habe ich mir zwar eine schöne grafische statische Oberfläche gebastelt, aber stehe vor dem Problem, dass ich nun eine Menge Klassen in unterschiedlichen Dateien habe

- Start.java (u. a. mit main-Methode, um das Spiel zu starten)
Erstellt eine neue Instanz von

Spiel

und ruft dort eine Methode auf. Außerdem erstellt sie eine Instanz von

Fenster

- Spiel.java (die wesentliche Programmablauflogik)
Erstellt dann zwei neue Spieler und lässt diese spielen

- Spieler.java
Enthält Attribute und Methoden, die durch Spiel.java geändert bzw. aufgerufen werden.

- Fenster.java
Erstellt erstmal ein leeren JFrame und fügt dann über

add

Elemente aus

Spielfeld

ein.

- Spielfeld.java
Enthält Funktionen zum malen von Objekten, erstellen von JLabels und JButtons usw., welche dann in

Fenster

erscheinen sollen.

Problematisch ist jetzt, dass ich die Attribute der Spieler (z. B. die Namen), die in

Spiel

erstellt wurden auch für das Spielfeld benötige (z. B. um ein JLabel mit dem Namen der Spieler zu versehen). Jetzt könnte ich zwar über die Methodenparameter immer die benötigten Attribute weitergeben, aber viel komfortabler wäre es doch, wenn ich die Spielerobjekte auch in Spielfeld (und weiteren Klassen zur Verfügung hätte). Ist das möglich?

Da es vorher so gut geklappt hat, habe ich mal wieder versucht ein vereinfachtes Beispiel zu bauen, was ähnlich wie mein Spiel aufgebaut ist.

Es gibt die genannten 5 Klassen (ergänzt um Präfix Test):
Teststart.java

public class Teststart {

	public static void main(String[] args) {

		// Spielernamen (in echt: Abfrage per JOption)
		String sp1_name = "Jack";
		String sp2_name = "Fohgel";
		// Testspieler sp1 = new Testspieler("Jack");
		// Testspieler sp2 = new Testspieler("Fohgel");
		
		// Ein Fenster für das Spiel erzeugen		
		Testfenster fenster = new Testfenster();
		// fenster.zeige_spielfeld();
		
		// Einen neue Instanz der Klasse Testspiel erstellen
		Testspiel spiel = new Testspiel();		
		// Das Spiel starten
		spiel.spielen(sp1_name, sp2_name);		// Unsauber?! Methode spielen() in Klasse Spieler?; 
		// Spielende
		System.out.println("Spielende!");
	}

}

Testspiel.java

public class Testspiel {
	
	// Defaultkonstruktor
	Testspiel() {}
	
	// Methoden
	public void spielen(String sp1_name, String sp2_name) { 
		
		// Erzeuge zwei neue Instanzen der Klasse Spieler		
		Testspieler sp1 = new Testspieler(sp1_name);
		Testspieler sp2 = new Testspieler(sp2_name);
		
		// Spielstart
		sp1.hatBall = true;					// Spieler 1 beginnt
		// Solange mind. ein Spieler den Ball hat, wird gespielt
		while(sp1.dauer < 10 || sp2.dauer < 10){ 
			
			// Spieler 1 spielt solange bis er abgibt oder 10 Runden den Ball hatte
			while(sp1.hatBall == true && sp1.dauer < 10) {		
					sp1.halten();
			}
			// Spieler 2 bekommt den Ball nach Abgabe oder 10 Runden von Spieler 1
			sp2.hatBall = true;
			while(sp2.hatBall == true && sp2.dauer < 10) {
					sp2.halten();
			}
			// Spieler 1 bekommt den Ball wieder nach Abgabe oder 10 Runden
			sp1.hatBall = true;
			
		}
	}
	
}

Testspieler.java

import javax.swing.JOptionPane;


public class Testspieler {
	
	// Attribute
	String name = "Nobody";
	boolean hatBall = false;
	int dauer = 0;
			
	// Konstruktor
	Testspieler(String name)
	{
		this.name = name;
	}
	
	// Methoden
	public void halten() {
		dauer += 1;
		int benutzereingabe;
		benutzereingabe = 	JOptionPane.showConfirmDialog(null, "Willst du den Ball behalten?",
							"Weiter?", JOptionPane.YES_NO_OPTION);
		if(benutzereingabe == 1)
		{
			abgeben();
		} else {
			System.out.println(name + " behält den Ball. (Dauer: " + dauer + ")");
		}
	}
	
	public void abgeben() {
		System.out.println(name + " gibt den Ball ab.");
		hatBall = false;
	}
}

Testfenster.java

import javax.swing.JFrame;


public class Testfenster extends JFrame {
    
	// Default-Konstruktor
	Testfenster() {
		
	   	setTitle("Testspiel");							// Fenstertitel setzen
    	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);	// Programm mit [x] beenden
        setVisible(true);                               // Fenster sichtbar machen
        setResizable(false);							// Größenänderung durch Benutzer deaktivieren
  
        //Spielfeld spfeld = new Spielfeld();      		// Eine neue Instanz von Spielbrett erzeugen
        //add(spfeld);                     	          	// Panel (Spielbrett) dem Fenster hinzufügen
        zeige_spielfeld();
                
        //setSize(800,600);								// Fenstergröße setzen
        pack();                                     	// Fenstergröße von Inhalt abhängig machen
        setLocationRelativeTo(null);					// Fenster auf Bildschirm zentrieren
	}	
    
	
	// Methoden
    public void zeige_spielfeld()
    {
        Testspielfeld spfeld = new Testspielfeld();      // Eine neue Instanz von Spielbrett erzeugen
        add(spfeld); 									 // Spielfeld dem Frame hinzufügen
    }
}

Testspielfeld.java

import java.awt.*;

import javax.swing.*;

public class Testspielfeld extends JPanel {
	
	// Attribute
		
		// Standarddimensionen für Panel
		int fensterbreite = 800;			// Breite des Spielfeldes
		int fensterhoehe = 600;				// Höhe des Spielfeldes
		// Standard für Textfelder
		String schrift_art = "SansSerif";	// Standardschriftart
		int schrift_groesse = 14;			// Ausgangsschriftgröße
	
	
	// Konstruktor
    Testspielfeld() {
    	
    	// Male den Spielfeldhintergrund
    	setBackground(Color.gray);                  // Hintergrundfarbe für Panel setzen
    	setPreferredSize(new Dimension(fensterbreite, fensterhoehe));  // Größe des Panels setzen
    	setLayout(null);          					// Keinen Layoutmanager benutzen
        zeige_spieler();							// Spielernamen anzeigen
        //!!! Auch hier müssten die Parameter Spielernamen,
        // wieder durchgereicht werden von Testfenster. Da wurde
        // es mir zu undurchsichtig und ich dachte da muss es doch eine
        // elegantere Lösung geben
        
   
    }
    
    // Methoden
    // Spielernamen anzeigen
    public void zeige_spieler() {
    	// Schriftstil auswählen
    	Font schrift_sp = new Font(schrift_art, Font.BOLD, schrift_groesse);
    	// Spielername - Spieler 1
    	JLabel txt_sp1_name = new JLabel("sp1.name", JLabel.CENTER);	// Objekt der Klasse JLabel erstellen
    	txt_sp1_name.setFont(schrift_sp);							// Schrift zuordnen
    	txt_sp1_name.setForeground(Color.black);					// Schriftfarbe
    	txt_sp1_name.setBounds(10, 550, 200, 30);					// Ausrichtung und Größe
    	txt_sp1_name.setOpaque(true); 								// Transparenz des Textfeldes aufheben
    	txt_sp1_name.setBackground(Color.yellow);					// Hintergrundfarbe
    	// Spielername - Spieler 2
    	JLabel txt_sp2_name = new JLabel("sp2.name", JLabel.CENTER);// Objekt der Klasse JLabel erstellen
    	txt_sp2_name.setFont(schrift_sp);							// Schrift zuordnen
    	txt_sp2_name.setForeground(Color.black);					// Schriftfarbe
    	txt_sp2_name.setBounds(590, 550, 200, 30);					// Ausrichtung und Größe
    	txt_sp2_name.setOpaque(true); 								// Transparenz des Textfeldes aufheben
    	txt_sp2_name.setBackground(Color.yellow);					// Hintergrundfarbe
    	// Spielernamen den Panel hinzufügen
    	add(txt_sp1_name);
    	add(txt_sp2_name);
    }
    
}

Man, so lang sollte das garnicht werden, aber ich hoffe das Problem wird dadurch deutlich. sp1.name, sp2.name usw. soll am besten global verfügbar sein, ohne, dass ich das von Klasse zu Klasse über Parameter weitergeben muss. Ich könnte das Ganze jetzt ja versuchen in eine Klasse zu packen, aber ich bin mir sicher, dass hier die Grenzen eher im meinem Kopf als in der Objektorientierung liegen.

Ich hoffe ihr könnt mir ähnlich hilfreich wie gestern unter die Arme greifen.

Freundliche Grüße
Kackfohgel

 

[kaetzacoatl]

Mach doch bei der Spiel-Klasse eine Methode
getPlayer, von der du dann einen Spieler
bekommst.

 

[Kackfohgel]

Hallo nochmal,

ich war ein verlängertes Wochenende nicht Zuhause; deshalb melde ich mich erst jetzt zurück.

Vielen Dank auch für deine Antwort kaetzacoatl.

Ich überarbeite derzeit die gesamt Klassen- und Dateistruktur*, weil ich glaube die oben geschilderte Aufteilung ist nicht sinnvoll.

Vlt. ist auch der Punkt gekommen, wo man diesen Thread auf "erledigt" setzt. Bei dem Anfangsproblem wurde mir ja erfolgreich geholfen und sollte ich auch mit einer anderen Struktur nicht weiterkommen, ist es vlt. besser einen neuen Thread aufzumachen.

Vielen Dank an alle, die sich mit meinem Problem beschäftigt und geantwortet haben.

Gruß
Kackfohgel


*Tipps für eine sinnvolle Aufteilung bleiben natürlich Willkommen