Du schreibst nicht was dein Problem ist. Ist es mehr das Darstellen des Spielfeldes oder eher die Logik in dem Spiel?

Naja, du brauchst einen Würfel (random-Funktion) und musst die aktuellen Figurenplätze speichern, sowie die Start und Zielfelder der einzelnen Spieler.
Ich denke mal, wenn du den Spielfelder IDs zuweist, dann wollte das weiterrücken einfach sein. Dann noch überprüfen, ob das Feld bereits besetzt ist und eine Methode um die Figuren dann auch graphisch dahin ziehen zu lassen.
Habe mir aber nicht deinen Code angeschaut.

Bei konkreten Fragen bekommst du bestimmt mehr Feedback...

also, starthilfe:

array spielfeld vom typ figur
nil = kein spielstein, ansonsten zeiger auf den jeweiligen spielstein.

klasse figur:
spielerzugehörigkeit, figurnummer (1 bis 4)
position (indizes vom array), -1 z.b. für startfeld, -2 für ziel

klasse spieler:
startfeld, zielfeld (int) -> arrayindizes
evtl zeiger auf figuren

klasse würfel
ist klar, 3 würfel oder so (wieviele hat man?), werden per random berechnet


was geschieht in einem zug?
spieler würfelt
spieler wählt spielstein
spielstein rückt vor (array

bevor ein stein rückt:
prüfen, ob zielfeld besetzt, wenn ja, andere spielfigur "runterschmeißen"



damit solltest du schon etwas anfangen können.

Dann zeig uns doch mal was du schon hast.

"SeBBo" schrieb:

bitte leute helft mir doch ein bisschen ist echt total wichtig ich bekomm ne 6 hilfe!!!!!

Hi,

ich kann dir mal bei der Programmlogik (~Spezifikation) helfen, ausprogrammieren (~implementieren) musst du es dann aber selbst

Geh prozessorientiert vor:

Haupt-Prozesse (mit noch zu spezifizierenden Subprozessen der Objektmethoden):
(A) Spieler wechseln
(B) Würfeln
(C) Ziehen

Prozess (C) wird dabei am "komplexten" sein.

Definier also Objekte mit entsprechenden Attributen und Methoden

(1) Wuerfel
Attribute:: (Integer) Augen
Methoden:: Wurf: Integer

(2) Figur
Attribute:: (String) Farbe, (Array[Farbe,Integer]) Position
Methoden:: Ziehen (Wuerfel.Augen): Position

Bem.: Für die Position denkst du dir das Spielbrett in vier Bereiche nach den Farben aufgeteilt. Der Integer Wert nummeriert dann die Felder durch (0-3) Home, (4-N) Aktiv, (N+1-N+4) Ziel. Wenn z.B. Rot neben Blau ist, wäre Position[Blau,N+1] ein Ziel für Rot und Position[Rot,0] zB. im Homepool von Rot. Es ändert sich dann zB. die Position[Blau,N] auf Position[Rot,4] wenn Blau um 1 zieht. Auch ändert sich zB. die Position[Rot,0] auf Position[Rot,4] wenn Rot mit 6 zieht.
Die Logik hierfür steckt in der Methode Ziehen.

(3) Spieler
Attribute:: (String) Name, (String) Farbe, (Array[String]: Liste(Figur)) Figurpool: Home, Aktiv, Ziel
Methoden:: Zug: ruft Figur.Ziehen

(4) Spiel
Attribute:: (Liste) Spieler
Methoden:: Main, Wechsel(Spieler), Wuerfeln(Wuerfel), Ziehen(Spieler): Spieler.Zug

PS: Getter und Setter habe ich weggelassen

Algorithmus (für statische Spiel.Main Prozedur):

- Initialisieren:
-- Spieler S1,..,S4, Sn.Farbe
-- Figur R1-R4 ... B1-B4, R1.Position=[Rot,0], R2.Position=[Rot,1]...
-- S1.Figurpool[Home]=(R1..R4), S1.Figurpool[Aktiv]=(nil), S1.Figurpool[Ziel]=(nil) ...
-- Spiel.Spieler

- Spieler wechseln:
Spiel.Wechsel(Sn) -> next(Spiel.Spieler)

- Wuerfeln
Wuerfel.Wurf -> Wuerfel.Augen

- Ziehen
Sn.Zug

Sn.Zug beinhaltet die Spielregeln (zB. Bei einer 6 muss man raus stellen und darf nicht rauswerfen oder so) und die Strategie (ins Ziel oder rauswerfen ?), etc. und wertet Wuerfel.Augen aus.
Als Ergebnis der Logik werden Figur.Position geändert (zB R1.Position) und Sn.Figurpool[..]. Zb. ob R1.Ziehen(Wuerfel.Augen) = Bn.Position -> Rauswurf. Wenn S2 Blau hat dann muss neben Bn.Position auch S2.Figurpool[..] angepasst werden. Für den Rauswurf müssen nur Figur.Position der Figuren in Sn.Figurpool[Aktiv] getestet werden. Wer zuerst alle Figuren in Sn.Figurpool[Ziel] hat, hat gewonnen.

HTH