package game;
import java.io.*;
import java.lang.*;
import java.util.Random;
import game.*;
import maedn.SpielMenu;
import java.util.List;
public class SpielAblauf {
private Random zufall = new Random();
private int[] wuerfelStatistik = new int[18];
private int wuerfelStatistikZaehler = 0,
ziehe = 10000;
Spielfeld spielplan;
SpielMenu spielmenu;
String ausgabeText = "nix",
name;
public static final char blau= 'b';
public static final char rot= 'r';
public static final char ygelb= 'y';
public static final char gruen= 'g';
// public boolean gewürfelt= false;
private char spieler = gruen;
private boolean wuerfelStatus = false,
wuerfelAngeklikt = false,
gewonnen = false,
isComputer = true,
weiterSpielen = false,
ziehenMoeglich[] = new boolean[4];
private int gewaehltesFeld = 10000,
startPos,
erster = 0;
private int[] Stein = new int[4];
private int[] globaleSteinPos = new int[4];
Spieler spielerBlau = new Spieler('b', "Bernd", true, true, 0);
Spieler spielerRot = new Spieler('r', "Ronja", true, true, 10);
Spieler spielerYgelb = new Spieler('y', "Yvonne", true, true, 20);
Spieler spielerGruen = new Spieler('g', "Gerd", true, true, 30);
public SpielAblauf()
{
}
public SpielAblauf(Spielfeld spielplan)
{
this.spielplan = spielplan;
}
public SpielAblauf(Spielfeld spielplan, String bName, boolean bAktiv, boolean bComp,
String rName, boolean rAktiv, boolean rComp,
String yName, boolean yAktiv, boolean yComp,
String gName, boolean gAktiv, boolean gComp) {
this.spielplan = spielplan;
spielerBlau. neueBelegung(bName, bAktiv, bComp);
spielerRot. neueBelegung(rName, rAktiv, rComp);
spielerYgelb.neueBelegung(yName, yAktiv, yComp);
spielerGruen.neueBelegung(gName, gAktiv, gComp);
if (spielerBlau .isAktiv() == true) spielplan.setStein(0);
if (spielerRot .isAktiv() == true) spielplan.setStein(1);
if (spielerYgelb.isAktiv() == true) spielplan.setStein(2);
if (spielerGruen.isAktiv() == true) spielplan.setStein(3);
// Ablauf des Spiels
do {
do {
switch (spieler) {
case blau: spieler = rot;
break;
case rot: spieler = ygelb;
break;
case ygelb: spieler = gruen;
break;
case gruen: spieler = blau;
break;
}
System.out.println(spieler);
if (spieler == blau && spielerBlau.isAktiv() == true) gewonnen = SpielZug();
if (spieler == rot && spielerRot.isAktiv() == true) gewonnen = SpielZug();
if (spieler == ygelb && spielerYgelb.isAktiv() == true) gewonnen = SpielZug();
if (spieler == gruen && spielerGruen.isAktiv() == true) gewonnen = SpielZug();
}
while (gewonnen == false);
// Gewonnen !!!
// Statistik
// lade Statistik
//if (isComputer == false) mensch = mensch +1;
//else computer = computer +1;
// speichere Statistik
// Mitteilung
erster = erster + 1;
if (spieler == blau) name = spielerBlau.getName();
if (spieler == rot) name = spielerRot.getName();
if (spieler == ygelb) name = spielerYgelb.getName();
if (spieler == gruen) name = spielerGruen.getName();
if (erster == 1) {
if (isComputer == true) ausgabeText = name + " hat gewonnen.";
else ausgabeText = "Herzlichen Glückwunsch " + name +
". Du hast gewonnen!!!";
}
else {
if (isComputer == true) ausgabeText = name + " ist " + erster +
". geworden.";
else ausgabeText = "Herzlichen Glückwunsch " + name + ". Du bist " + erster +
". geworden.";
}
ausgeben();
// Weiterspielen?
ausgabeText = "Soll das Spiel fortgesetzt werden?";
ausgeben();
// weiterSpielen = ;
// isAktiv verändern
}
while (weiterSpielen == true);
}
public boolean getWuerfelStatus () {
return wuerfelStatus;
}
public void transFeld (int pos) { // set
gewaehltesFeld = pos;
System.out.println("angeklicktes Feld: "+gewaehltesFeld);
}
public void hatGewuerfelt() {
wuerfelAngeklikt = true;
}
private void ausgeben() {
spielplan.setMsg(ausgabeText);
}
private void setStein(int nr, int pos) {
Stein[nr] = pos;
}
private int getStein(int nr) {
return Stein[nr];
}
private int getStartposition() {
return startPos;
}
private int getGlobaleSteinPos(int nr) {
return globaleSteinPos[nr];
}
private void steinWahlMensch() {
int[] globPosZiehbSteine = new int[4];
int[] globPosEigeneSteine = new int[4];
for (int i = 0; i < 4; i++) {
if (ziehenMoeglich[i] = true) globPosZiehbSteine[i] =
globPosEigeneSteine[i] = globaleSteinPos[i];
}
boolean nochmal = true;
do {
boolean eigene = false;
for (int i = 0; i < 4; i++) {
if (globPosZiehbSteine[i] == gewaehltesFeld) ziehe = i;
if (globPosEigeneSteine[i] == gewaehltesFeld) eigene = true;
}
if (ziehe < 0 || ziehe > 4) {
if (eigene = true) ausgabeText = "Bitte wähle einen anderen Stein.";
else ausgabeText = "Bitte wähle einen eigenen Stein.";
ausgeben();
}
else nochmal = false;
}
while (nochmal = true);
}
private boolean dreiMalWuerfeln() {
boolean dreiMal = false,
feld43 = false,
feld42 = false,
feld41 = false;
int imHof = 0,
hilf;
for (int i=0; i<4; i++) {
hilf = getStein(i);
if (hilf >= 100) imHof = imHof +1;
if (hilf == 43) feld43 = true;
if (hilf == 42) feld42 = true;
if (hilf == 41) feld41 = true;
}
if (imHof == 4)
dreiMal = true;
if (feld43 == true) {
if (imHof == 3) dreiMal = true;
else {
if (feld42 == true) {
if (imHof == 2) dreiMal = true;
else {
if (feld41 == true) {
if (imHof == 1) dreiMal = true;
}
}
}
}
}
return dreiMal;
}
/**
* würfelt eine Zahl zwischen 1 und 6 und gibt sie zurück
*/
private int wuerfeln() {
// setzte die Wuerfelgrafik anklikbar
wuerfelStatus = true;
boolean geheWeiter = false;
do
{
System.out.println("Bitte würfeln");
wuerfelAngeklikt = spielplan.getWürfelKlick();
System.out.println("Würfel wurde Angeklickt: "+wuerfelAngeklikt);
if (wuerfelAngeklikt == true)
{
geheWeiter = true;
System.out.println("Gehe weiter: " +geheWeiter);
}
break;
} while (geheWeiter == false);
// wenn der Wuerfel angeklikt wurde
// deaktiviere Wuerfelgrafik anklikbar
wuerfelStatus = false;
wuerfelAngeklikt = false;
// neu wuerfeln
int neuerWurf,
nul = 0,
eins = 0,
zwei = 0,
drei = 0,
vier = 0,
fuenf = 0,
sechs = 0;
neuerWurf = zufall.nextInt(6) + 1;
// Ausgleich des Erwartungswertes
for (int i=0;i<18;i++) {
switch (wuerfelStatistik[i]) {
case 1: eins = eins +1; break;
case 2: zwei = zwei +1; break;
case 3: drei = drei +1; break;
case 4: vier = vier +1; break;
case 5: fuenf = fuenf +1; break;
case 6: sechs = sechs +1; break;
default: nul = nul +1; break;
}
}
if (nul == 0) {
if (eins == 0) neuerWurf = 1;
if (zwei == 0) neuerWurf = 2;
if (drei == 0) neuerWurf = 3;
if (vier == 0) neuerWurf = 4;
if (fuenf == 0) neuerWurf = 5;
if (sechs == 0) neuerWurf = 6;
}
wuerfelStatistikZaehler = wuerfelStatistikZaehler +1;
if (wuerfelStatistikZaehler > 17) wuerfelStatistikZaehler = wuerfelStatistikZaehler -18;
wuerfelStatistik[wuerfelStatistikZaehler] = neuerWurf;
// aktuallisieren der Wuerfelgrafik
spielplan.refreshWürfel(neuerWurf);
return neuerWurf;
}
private boolean kannSchlagen(int nr, int augenZahl) {
boolean schlagen = false;
int pos,
hilf,
hilf2;
hilf = getStein(nr);
hilf2 = getStartposition();
if (hilf < (40 + augenZahl)) {
pos = hilf + hilf2 + augenZahl;
if (pos >= 40) pos = pos - 40;
if (spielplan.elementAt(pos) != 'n') schlagen = true;
if (spielplan.elementAt(pos) != spieler) schlagen = true;
}
return schlagen;
}
private boolean kannZiehen(int nr, int augenZahl) {
boolean ziehen = true;
int hilf = getStein(nr);
// im Spiel oder Haus
if (hilf < 100) {
if (hilf + augenZahl >= 44)
ziehen = false;
else {
// letztes Hausfeld
for (int i = 0; i < 4; i++) {
// eigener Stein
if ((hilf + augenZahl) == getStein(i)) ziehen = false;
}
}
}
// im Hof
else {
// Würfel != 6
if (augenZahl < 6)
ziehen = false;
else {
// Startfeld besetzt
for (int i = 0; i < 4; i++) {
if (getStein(i) == 0) ziehen = false;
}
}
}
return ziehen;
}
private void SteinSchlagen(char geschlageneFarbe, int geschlagenePosGlob){
int steinNr = 10000,
freiesHofFeld = 10000;
boolean[] feldFrei = new boolean[4];
spielplan.setElementAt('n', geschlagenePosGlob);
for (int i = 0; i < 4; i++) {
feldFrei[i] = true;
if (geschlageneFarbe == blau) {
if (spielerBlau.getGlobaleSteinPos(i) == geschlagenePosGlob) steinNr = i;
if (spielerBlau.getStein(i) >= 100) feldFrei[spielerBlau.getStein(i) - 100] = false;
}
if (geschlageneFarbe == rot) {
if (spielerRot.getGlobaleSteinPos(i) == geschlagenePosGlob) steinNr = i;
if (spielerRot.getStein(i) >= 100) feldFrei[spielerRot.getStein(i) - 100] = false;
}
if (geschlageneFarbe == ygelb) {
if (spielerYgelb.getGlobaleSteinPos(i) == geschlagenePosGlob) steinNr = i;
if (spielerYgelb.getStein(i) >= 100) feldFrei[spielerYgelb.getStein(i) - 100] = false;
}
if (geschlageneFarbe == gruen) {
if (spielerGruen.getGlobaleSteinPos(i) == geschlagenePosGlob) steinNr = i;
if (spielerGruen.getStein(i) >= 100) feldFrei[spielerGruen.getStein(i) - 100] = false;
}
}
for (int i=0; i<4; i++) {
if (feldFrei[i] = true) freiesHofFeld = i;
}
if (geschlageneFarbe == blau) {
spielerBlau.setStein(steinNr, 100 + freiesHofFeld);
freiesHofFeld = freiesHofFeld + 1100;
}
if (geschlageneFarbe == rot) {
spielerRot.setStein(steinNr, 100 + freiesHofFeld);
freiesHofFeld = freiesHofFeld + 2100;
}
if (geschlageneFarbe == ygelb) {
spielerYgelb.setStein(steinNr, 100 + freiesHofFeld);
freiesHofFeld = freiesHofFeld + 3100;
}
if (geschlageneFarbe == gruen) {
spielerGruen.setStein(steinNr, 100 + freiesHofFeld);
freiesHofFeld = freiesHofFeld + 4100;
}
// spielplan.setzeStein(geschlageneFarbe, geschlagenePosGlob, freiesHofFeld);
}
private void datenAbgleich() {
for (int i = 0; i < 4; i++) {
if (spieler == blau) spielerBlau.setStein(i, Stein[i]);
if (spieler == rot) spielerRot.setStein(i, Stein[i]);
if (spieler == ygelb) spielerYgelb.setStein(i, Stein[i]);
if (spieler == gruen) spielerGruen.setStein(i, Stein[i]);
}
}
private boolean SpielZug () {
char geschlageneFarbe;
int geschlagenePosGlob,
anzWuerfeln,
augenZahl,
pos[] = new int[4];
boolean kannFigurBewegen,
steinImHof,
steinAufStart,
gewonnen;
Wuerfel wuerfel;
do {
// Daten für diesen Spielzug einlesen
for (int i = 0; i<4; i++) {
if (spieler == blau) {
Stein[i] = spielerBlau.getStein(i);
globaleSteinPos[i] = spielerBlau.getGlobaleSteinPos(i);
isComputer = spielerBlau.isComputer();
startPos = spielerBlau.getStartposition();
}
if (spieler == rot) {
Stein[i] = spielerRot.getStein(i);
globaleSteinPos[i] = spielerRot.getGlobaleSteinPos(i);
isComputer = spielerRot.isComputer();
startPos = spielerRot.getStartposition();
}
if (spieler == ygelb) {
Stein[i] = spielerYgelb.getStein(i);
globaleSteinPos[i] = spielerYgelb.getGlobaleSteinPos(i);
isComputer = spielerYgelb.isComputer();
startPos = spielerYgelb.getStartposition();
}
if (spieler == gruen) {
Stein[i] = spielerGruen.getStein(i);
globaleSteinPos[i] = spielerGruen.getGlobaleSteinPos(i);
isComputer = spielerGruen.isComputer();
startPos = spielerGruen.getStartposition();
}
}
System.out.println("SpielAblauf zeile 305 "+spieler+" "+Stein[0]+" "+Stein[1]+" "+Stein[2]+" "+Stein[3]+" "+startPos);
// Variablen initialisieren
geschlageneFarbe = 'n';
anzWuerfeln = 1;
augenZahl = 0;
ziehe = 10000;
geschlagenePosGlob = 10000;
kannFigurBewegen = false;
steinImHof = false;
steinAufStart = false;
gewonnen = false;
for (int i=0; i<4; i++) {
ziehenMoeglich[i] = false;
pos[i] = 10000;
}
wuerfel = new Wuerfel();
// 3 mal wuerfeln?
if (dreiMalWuerfeln() == true) anzWuerfeln = 3;
// System.out.println("anzWuerfeln = " + anzWuerfeln);
// Würfeln
do {
anzWuerfeln = anzWuerfeln -1;
augenZahl = wuerfeln();
if (augenZahl == 6) anzWuerfeln = 0;
System.out.println("SpielAblauf zeile340 Augenzahl = " + augenZahl);
}
while (anzWuerfeln > 0);
// Welche Steine koennen ziehen?
for (int i=0; i<4; i++) {
if (kannZiehen(i, augenZahl) == true) {
ziehenMoeglich[i] = true;
kannFigurBewegen = true;
}
if (getStein(i) >= 100) steinImHof = true;
// Zugfaehige Figur auf Startfeld?
if (getStein(i) == getStartposition()) {
steinAufStart = true;
if (ziehenMoeglich[i] == true) ziehe = i;
}
}
System.out.println("SpielAblauf zeile 358 kannFigurBewegen " + kannFigurBewegen);
System.out.println("SpielAblauf zeile 359 steinAufStart " + steinAufStart);
// Zug moeglich
if (kannFigurBewegen == true) {
//System.out.println("zeile 330 "+ spieler + Stein[0] + Stein[1] + Stein[2] + Stein[3]);
// Computer
if (isComputer == true) {
// 6 gewuerfelt, Startfeld frei und min einen Stein im Hof?
if (steinAufStart == false && steinImHof == true) {
if (augenZahl == 6) {
for (int i = 0; i < 4; i++) {
if (getStein(i) > 99) ziehe = i;
}
System.out.println("SpielAblauf zeile 374 ziehe stein "+ziehe);
}
}
if (ziehe == 10000) {
// sortieren
System.out.println("SpielAblauf zeile 380 sortieren anfangen");
for (int j = 0; j < 3; j++) {
for (int i = 0; i < 3; i++) {
if (getStein(i) > getStein(i + 1)) {
int hilfe = getStein(i);
setStein(i, getStein(i + 1));
setStein(i + 1, hilfe);
}
}
}
System.out.println("SpielAblauf zeile 390 sortiert "+getStein(0)+" "+getStein(1)+" "+getStein(2)+" "+getStein(3));
// schlagen möglich
for (int i = 0; i < 4; i++) {
if (kannSchlagen(i, augenZahl) == true) ziehe = i;
}
if (ziehe == 10000) {
// ziehen
for (int i = 0; i < 4; i++) {
if (kannZiehen(i, augenZahl)) ziehe = i;
}
}
}
}
// Mensch
else {
if (ziehe == 10000) {
// 6 gewürfelt, Startfeld frei und min einen Stein im Hof?
if (augenZahl == 6 && steinAufStart == false && steinImHof == true) {
for (int i = 0; i < 4; i++) {
pos[i] = 10000;
if (getStein(i) >= 100) pos[i] = getStein(i);
}
}
// schlagen moeglich?
if (augenZahl != 6 || steinAufStart == true || steinImHof == false) {
for (int i = 0; i < 4; i++) {
if (kannSchlagen(i, augenZahl) == true) {
geschlageneFarbe = spieler;
geschlagenePosGlob = getGlobaleSteinPos(i);
}
}
}
}
else {
for (int i = 0; i < 4; i++) {
pos[i] = 10000;
}
pos[ziehe] = getStein(ziehe);
}
// Globale Position ermitteln ziehenMoeglich
for (int i = 0; i < 4; i++) {
if (pos[i] != 10000) pos[i] = getGlobaleSteinPos(i);
}
// Zugwahl abfragen
// ziehe = spielplan.ZugWahl(spieler, pos[0], pos[1], pos [2], pos[3]);
ziehe = 1; // ersatzweise fuer die zeile darueber
}
// Zug ausfuehren
// schlagen?
if (kannSchlagen(ziehe, augenZahl) == true) {
geschlagenePosGlob = getGlobaleSteinPos(ziehe) + augenZahl;
if (geschlagenePosGlob >= 40) geschlagenePosGlob = geschlagenePosGlob - 40;
geschlageneFarbe = spielplan.elementAt(geschlagenePosGlob);
}
// geschlagene Figur entfernen
if (geschlageneFarbe != 'n') {
SteinSchlagen(geschlageneFarbe, geschlagenePosGlob);
}
// Figur ziehen
int zugBeginn = getGlobaleSteinPos(ziehe),
zugEnde = getGlobaleSteinPos(ziehe) + augenZahl;
if (getStein(ziehe) < 100) {
if (getStein(ziehe) < 40) spielplan.setElementAt('n', zugBeginn);
setStein(ziehe, getStein(ziehe) + augenZahl);
if (getStein(ziehe) + augenZahl < 40) {
if (zugEnde >= 40) zugEnde = zugEnde -40;
spielplan.setElementAt(spieler, zugEnde);
}
else {
if (spieler == blau) zugEnde = 1000;
if (spieler == rot) zugEnde = 2000;
if (spieler == ygelb) zugEnde = 3000;
if (spieler == gruen) zugEnde = 4000;
zugEnde = zugEnde + getStein(ziehe) + augenZahl;
}
}
// Figur ins Spiel bringen
else {
System.out.println("zeile 440 Figur ins Spiel bringen " + ziehe);
setStein(ziehe, getStartposition());
zugEnde = getStartposition();
spielplan.setElementAt(spieler, zugEnde);
}
System.out.println("Spieler Farbe :" +spieler+ " ; Anfangsposition: "+zugBeginn+" ; Endposition: "+zugEnde);
spielplan.setzeStein(spieler, zugBeginn, zugEnde);
datenAbgleich();
}
// kann nicht ziehen
else {
String aName = "Keiner";
if (isComputer == true) {
if (spieler == blau) aName = spielerBlau .getName();
if (spieler == rot) aName = spielerRot .getName();
if (spieler == ygelb) aName = spielerYgelb.getName();
if (spieler == gruen) aName = spielerGruen.getName();
ausgabeText = aName + " kann keine Figur bewegen.";
}
else {
ausgabeText = "Du kannst keine Figur bewegen.";
}
// ausgeben();
}
/* Grafik aufrufen
int[] blau = new int[4],
rot = new int[4],
ygelb = new int[4],
gruen = new int[4];
for (int i = 0; i<4;i++){
blau[i] = spielerBlau. getGlobaleSteinPos(i);
rot[i] = spielerRot. getGlobaleSteinPos(i);
ygelb[i] = spielerYgelb.getGlobaleSteinPos(i);
gruen[i] = spielerGruen.getGlobaleSteinPos(i);
}
*/
System.out.println("zeile 469"+ spieler);/*+" "+blau[0]+" "+ blau[1]+" "+ blau[2]+" "+ blau[3]+" "+
rot[0]+" "+ rot[1]+" "+ rot[2]+" "+ rot[3]+" "+
ygelb[0]+" "+ ygelb[1]+" "+ ygelb[2]+" "+ ygelb[3]+" "+
gruen[0]+" "+ gruen[1]+" "+ gruen[2]+" "+ gruen[3]);
System.out.println (augenZahl);*/
// spielplan.setzeStein(char, int, int);
//boolean wahr = false;
//wahr = ((augenZahl == 6) && (gewonnen == false));
//System.out.println("zeile 487 "+ wahr);
}
// Wuerfelt dieser Spieler nochmal?
while ((augenZahl == 6) && (gewonnen == false));
//System.out.println("kommt aus dieser schleife raus");
return gewonnen;
}
}
