# Problem mit Tic Tac Toe



## Bene1991 (30. Aug 2008)

Hallo leute,

wir sollen von der Schule aus das spiel Tic Tac toe programmieren. Allerdings soll es nich als Applet sein sondern durch die Konsole. Jetzt hab ich folgendes Problem. Ich hab angefangen damit dass ich ziehe. Danach sucht der Computer sich zufällig ein Feld aus. Nur das Problem is, wenn er genau das selbe Feld auswählt wie dann passiert gar nicht und ich bin wieder dran. 
Ich hab das ganze in eine Funktion geschrieben so wie wirs gelernt haben.
Als so viel kennen wir noch nicht aber mein Lehrer meinte mit unseren Mitteln sei das zu schaffen.
Wenn ihr wollt kann ich euch den Quelltext noch dazu posten.
Ich hoffe ihr könnt mir helfen 

Bene


----------



## foobar (30. Aug 2008)

Wenn der Computer welches Feld auswählt?

Ich vermute mal du meinst, wenn der Computer ein schon besetzes Feld auswählt. Du brauchst eine Datenstruktur z.b. ein Field[][] in dem du alle Felder speicherst. Die Klasse Feld stellt dann den Zustand eines Felder dar also offen oder besetzt von Computer/Spieler. Wenn der Computer ein Feld besetzen soll, mußt du solange eine Zufallszahl generieren bis du ein freies Feld findest.

Poste mal deinen Code, dann können wir dir besser helfen.


----------



## Guest (30. Aug 2008)

```
public class TicTacToe
{

	//globale Variablen
	static char  feld11,feld12,feld13,feld21,feld22,feld23,feld31,feld32,feld33;
	static int eingabe;
	static double zahl;
	static int spielZustand; 	//0 spiel läuft
								//1 pc gewinnt
								//2 spieler gewinnt
								//3 unentschieden


	//---------------------------------------------------------------------------------------------------------------------------

	public static void spielerZieht()
	{
		Konsole kons = new Konsole();

		System.out.print("Bitte geben sie ein in welches Feld sie ihr Kreuz setzen wollen//\nEingabemodus ist XY  \n" );
		eingabe = kons.readInt();
		if(eingabe == 11)
		{
			feld11 = 'X';
		}
		if(eingabe == 12)
		{
			feld12 = 'X';
		}
		if(eingabe == 13)
		{
			feld13 = 'X';
		}
		if(eingabe == 21)
		{
			feld21 = 'X';
		}
		if(eingabe == 22)
		{
			feld22 = 'X';
		}
		if(eingabe == 23)
		{
			feld23 = 'X';
		}
		if(eingabe == 31)
		{
			feld31 = 'X';
		}
		if(eingabe == 32)
		{
			feld32 = 'X';
		}
		if(eingabe == 33)
		{
			feld33 = 'X';
		}

	}
//---------------------------------------------------------------------------------------------------------------------------------
	public static void ueberpruefen()
	{

	}
//---------------------------------------------------------------------------------------------------------------------------------
	public static void computerZieht()
	{

		zahl = Math.random()*9;
		if((int)zahl==0)
		{
			if(feld11 == 'X')
			{
				zahl++;
			}
			else
			{
				feld11 = 'O';
			}
		}
		if((int)zahl==1)
		{
			if(feld21 == 'X')
			{
				zahl++;
			}
			else
			{
				feld21 = 'O';
			}
		}
		if((int)zahl==2)
		{
			if(feld31 == 'X')
			{
				zahl++;
			}
			else
			{
				feld31='O';
			}
		}
		if((int)zahl==3)
		{
			if(feld12 == 'X')
			{
				zahl++;
			}
			else
			{
				feld12 = 'O';
			}
		}
		if((int)zahl==4)
		{
			if(feld22 == 'X')
			{
				zahl++;
			}
			else
			{
				feld22 = 'O';
			}
		}
		if((int)zahl==5)
		{
			if(feld32 == 'X')
			{
				zahl++;
			}
			else
			{
				feld32 = 'O';
			}
		}
		if((int)zahl==6)
		{
			if(feld13 == 'X')
			{
				zahl++;
			}
			else
			{
				feld13 = 'O';
			}
		}
		if((int)zahl==7)
		{
			if(feld23 == 'X')
			{
				zahl++;
			}
			else
			{
				feld23 = 'O';
			}
		}
		if((int)zahl==8)
		{
			if(feld33 == 'X')
			{
				zahl++;
			}
			else
			{
				feld33 = 'O';
			}
		}


	}
//---------------------------------------------------------------------------------------------------------------------------------

	public static void spielfeldAusgeben ()
	{
		System.out.print("Tic-Tac-Toe\n\n");
		System.out.print("\n\n\n\t1\t2\t3\n\n\n");
		System.out.print("1\t"+feld11+"\t"+feld21+"\t"+feld31+"\n\n\n\n2\t"+feld12+"\t"+feld22+"\t"+feld32+"\n\n\n\n3\t"+feld13+"\t"+feld23+"\t"+feld33+"\n\n\n\n\n\n\n\n");

	}
//---------------------------------------------------------------------------------------------------------------------------------
	public static void main (String args[])
	{

		Konsole kons = new Konsole();

		spielerZieht();
		spielfeldAusgeben();
		kons.cls();
		computerZieht();






	}

}
```

joa das is jetzt der Code
es geht eig nur um den Teil "computerZieht"


----------



## 0x7F800000 (30. Aug 2008)

1) omfg...
2) über arrays hat euch eurer lieber lehrer selbsverständlich nichts erzählt? Mach erstmal diese ganzen "feldXYZWIJK" variablen weg, das ist doch echt übertrieben... :shock:  Geh bei solchen sachen bitte immer davon aus, dass du morgen die sache für ein 10x10 Feld verallgemeinern musst, da ersparst du dir immer eine menge tipparbeit und schwer auffindbare "hoppla-index-verwechselt"-Fehler
3) warum soll denn bitte schön alles static sein, wofür ist das gut?
4) KI die zufällig irgendetwas ankreuzt ist kein besonders interessanter gegner. Implementier mal lieber eine unbesiegbare KI mit backtracking wenn du zeit hast: dast ist schön kurz, und wesentlich einfacher, als irgendwelche manuell überlegte taktiken.


----------



## Guest (30. Aug 2008)

ja also danke erst ma ...
aber über arrays hat er noch nichts gesagt. Bin auch erst ganz am Anfang von Java also viel Ahnung hab ich leider noch nicht. 
Dann dazu mit Static.
Er hat das so erklärt dass es daduch eine globale Variable is und in allen funktion bekannt ist.


----------



## 0x7F800000 (30. Aug 2008)

Zu Arrays: dann lies dir eben schenll was dazu durch, kostet ja nichts, erspart aber tonnen von ärger und unmengen von zeit. Du willst mir doch nicht ernsthaft erzählen, dass es dich nicht langweilt, denselben code für jedes einzelne feld neunmal hinzuschreiben?  Eins ist sicher: eine Tabelle mit X-en und O-en zu verwalten, ohne arrays zu benutzen ist ziemlich dasselbe wie mechanisches addieren von zahlen mithilfe eines streichholzhaufens...

Zu static: ja, allerdings. Und so wie es jetzt da steht, ist es nicht nur innerhalb der klasse überall sichtbar, sondern absolut vollkommen überall, da kann jeder dran rumfummeln wie er will... Das ist sehr unsauber und ist strickt gegen das prinzip der datenkapselung. Jede komponente des Programms sollte nicht mehr wissen als sie zu wissen braucht. Wenn dann etwas schief geht, lässt sich das Problem sehr viel schneller eingrenzen, als wenn du in einem riesenprogramm stundenlang nach irgendeinem übeltäter suchen musst, der eigentlich nichts damit zu tun haben sollte, aber trotzdem alles kaputtmacht, weil alles static und für jeden sichtbar ist.


----------



## Quaxli (30. Aug 2008)

Tja, nicht jeder Lehrer der Java unterrichtet, kann es selbst 

Wenn Du die Variablen "ganz oben" deklarierst, sind sie auch für jede Klasse sichtbar. Was static bedeutet liest Du am Besten selbst nach (z. B. www.javabuch.de).

Wenn Ihr wirklich noch keine Arrays hattet (was ich mir fast nicht vorstellen kann) geht es auch mit neun Feldern, ist aber sehr unschön.

Mal ein paar Tipps für eine einfache KI:

Vergib für jedes besetzte Feld eine Zahl, z. B. eine 1 für Deine Felder und eine 3 für KI Felder. Dann kann die KI ausrechnen, wo sie hinziehen muß, bzw. kann. D. h. die KI muß alle Spalten, Reihen und Diagonalen prüfen.

Wenn z. B. die Summe der Felder einer Reihe 2 ergibt "weiß" die KI, daß Du 2 Felder besetzt hast und sie das 3. besetzen muß, um einen Sieg zu verhindern, usw.


----------



## Bene1991 (1. Sep 2008)

so ich hab jetzt ne lösung gefunden ..
allerdings wählt der computer immer zufällig ein Feld aus. Soll für mich für den Anfang reichen !


----------



## foobar (1. Sep 2008)

Poste doch mal deine Lösung. Wir finden bestimmt noch etwas was man verbessern kann ;-)


----------



## Bene1991 (1. Sep 2008)

So jetzt hier meine Lösung .
Bin mir sogar 100% sicher dass man was verbessern kann aber unser lehrer mag es nicht wenn man sachen benutzt die wir nicht hatten. Deswegen is es jetzt auch ziemlich aufwendig geschrieben . Aber schaut selbst.


```
/**TIC TAC TOE**/
//-------------------------------------------------------------------------------------------------------------------------


public class TicTacToe2
{

	//Deklarierung der globalen Variablen//
	static char  feld1,feld2,feld3,feld4,feld5,feld6,feld7,feld8,feld9;
	static int bfeld1,bfeld2,bfeld3,bfeld4,bfeld5,bfeld6,bfeld7,bfeld8,bfeld9;
	static int eingabe;
	static double zahl;
	static int besetzt;
	static int korrekt;
	static double eingabeComputerberechnung;
	static int spielZustand; 	//0 spiel läuft
								//1 pc gewinnt
								//2 spieler gewinnt
								//3 unentschieden
	public static Konsole kons;



											/*Funktion damit Spieler am Zug ist */
//---------------------------------------------------------------------------------------------------------------------------


	public static void spielerZieht()
	{
		Konsole kons = new Konsole();

		do
		{
			kons.gotoXY(19,0);
			kons.print("YOUR TURN !!! CHOOSE YOUR FIELD!!! (1-9): ");
			eingabe = kons.readInt();
			kons.cls();

			if((eingabe==1)&&(bfeld1==0))
			{
				feld1 = 'X';
				bfeld1 = 1;
				korrekt = 1;
			}
			else
			{
				if((eingabe==2)&&(bfeld2==0))
				{
					feld2 = 'X';
					bfeld2 = 1;
					korrekt = 1;
				}
				else
				{
					if((eingabe ==3)&&(bfeld3==0))
					{
						feld3 = 'X';
						bfeld3 =1;
						korrekt = 1;
					}
					else
					{
						if((eingabe==4)&&(bfeld4==0))
						{
							feld4 = 'X';
							bfeld4 =1;
							korrekt=1;
						}
						else
						{
							if((eingabe==5)&&(bfeld5==0))
							{
								feld5='X';
								bfeld5=1;
								korrekt=1;
							}
							else
							{
								if((eingabe==6)&&(bfeld6==0))
								{
									feld6='X';
									bfeld6=1;
									korrekt=1;
								}
								else
								{
									if((eingabe==7)&&(bfeld7==0))
									{
										feld7='X';
										bfeld7=1;
										korrekt=1;
									}
									else
									{
										if((eingabe==8)&&(bfeld8==0))
										{
											feld8='X';
											bfeld8=1;
											korrekt=1;
										}
										else
										{
											if((eingabe==9)&&(bfeld9==0))
											{
												feld9='X';
												bfeld9=1;
												korrekt=1;
											}
											else
											{
												//fals das Feld bereits besetzt ist wird der Vorgang wiederholt//
												System.out.print("\n\nVersuchen sie es lieber noch einmal!!\n\n");
												korrekt=0;
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}while(korrekt==0);//end of do/while//
	}//end of Funktion "spielerZieht"//


					/**Funktion damit überpfrüft wird ob schon jemand gewonnen hat oder nicht*/
//---------------------------------------------------------------------------------------------------------------------------------
	public static void ueberpruefen()
	{
			//Hat der Spieler gewonnen?//
		if ((feld1 == 'X')&&(feld2 == 'X')&&(feld3 == 'X'))
		{//start of if
			spielZustand = 1;
		}//end of if
		else
		{
			if ((feld4 == 'X')&&(feld5 == 'X')&&(feld6 == 'X'))
			{//start of if
				spielZustand = 1;
			}//end of if
			else
			{
				if ((feld7 == 'X')&&(feld8 == 'X')&&(feld9 == 'X'))
				{//start of if
					spielZustand = 1;
				}//end of if
				else
				{
					if ((feld1 == 'X')&&(feld5 == 'X')&&(feld9 == 'X'))
					{//start of if
						spielZustand = 1;
					}//end of if
					else
					{
						if ((feld1 == 'X')&&(feld4 == 'X')&&(feld7 == 'X'))
						{//start of if
							spielZustand = 1;
						}//end of if
						else
						{
							if ((feld2 == 'X')&&(feld5 == 'X')&&(feld8 == 'X'))
							{//start of if
								spielZustand = 1;
							}//end of if
							else
							{
								if ((feld3 == 'X')&&(feld6 == 'X')&&(feld9 == 'X'))
								{//start of if
									spielZustand = 1;
								}//end of if
								else
								{
									if ((feld3 == 'X')&&(feld5 == 'X')&&(feld7 == 'X'))
									{//start of if
										spielZustand = 1;
									}//end of if
/*hat der computer gewonnen?*/		else
									{
										if ((feld1 == 'O')&&(feld2 == 'O')&&(feld3 == 'O'))
										{//start of if
											spielZustand = 2;
										}//end of if
										else
										{
											if ((feld4 == 'O')&&(feld5 == 'O')&&(feld6 == 'O'))
											{//start of if
												spielZustand = 2;
											}//end of if
											else
											{
												if ((feld7 == 'O')&&(feld8 == 'O')&&(feld9 == 'O'))
												{//start of if
													spielZustand = 2;
												}//end of if
												else
												{
													if ((feld1 == 'O')&&(feld5 == 'O')&&(feld9 == 'O'))
													{//start of if
														spielZustand = 2;
													}//end of if
													else
													{
														if ((feld1 == 'O')&&(feld4 == 'O')&&(feld7 == 'O'))
														{//start of if
															spielZustand = 2;
														}//end of if
														else
														{
															if ((feld2 == 'O')&&(feld5 == 'O')&&(feld8 == 'O'))
															{//start of if
																spielZustand = 2;
															}//end of if
															else
															{
																if ((feld3 == 'O')&&(feld6 == 'O')&&(feld9 == 'O'))
																{//start of if
																	spielZustand = 2;
																}//end of if
																else
																{
																	if ((feld3 == 'O')&&(feld5 == 'O')&&(feld7 == 'O'))
																	{//start of if
																		spielZustand = 2;
																	}//end of if
																	else
																	{
																		if ((besetzt == 9)&&(spielZustand == 0))
																		{
																			spielZustand = 3;
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}//end of Funktion "ueberpruefen"//



								/*Funktion wodurch ermittelt wird wer gewonnen hat!*/
//--------------------------------------------------------------------------------------------------------------------------------
	public static void sieger()
	{
						Konsole kons = new Konsole();

						if (spielZustand == 1)
							{
								System.out.println ("YOU WIN!!!!\n\n\n\n\n");
								kons.sleep(2500);

							}
						else if (spielZustand == 2)
							{
								System.out.println ("YOU LOSE !!!\n\n\n\n\n");
								kons.sleep(2500);

							}
						else if (spielZustand == 3)
							{
								System.out.println ("Keiner hat den Kampf gewonnen!!!!\n\n\n\n\n");
								kons.sleep(2500);

							}

	}//end of Funktion "Sieger"//


								/*Funktion in der der Computer am zug ist */
//---------------------------------------------------------------------------------------------------------------------------------
	public static void computerZieht()
	{

		do
		{
		//	zahl = Math.random()*9;

			//Eine Zufallszahl wird ermittelt welche bestimmt wo der Computer sein "O" setzt//
			eingabeComputerberechnung = (double) Math.random ()*9;
			zahl = (int) eingabeComputerberechnung;
			if((zahl==0)&&(bfeld1==0))
			{
				feld1 = 'O';
				bfeld1 = 1;
				korrekt = 1;
			}
			else
			{
				if((zahl==1)&&(bfeld2==0))
				{
					feld2 = 'O';
					bfeld2 = 1;
					korrekt = 1;
				}
				else
				{
					if((zahl ==2)&&(bfeld3==0))
					{
						feld3 = 'O';
						bfeld3 =1;
						korrekt =1;
					}
					else
					{
						if((zahl==3)&&(bfeld4==0))
						{
							feld4 = 'O';
							bfeld4 =1;
							korrekt=1;
						}
						else
						{
							if((zahl==4)&&(bfeld5==0))
							{
								feld5='O';
								bfeld5=1;
								korrekt=1;
							}
							else
							{
								if((zahl==5)&&(bfeld6==0))
								{
									feld6='O';
									bfeld6=1;
									korrekt=1;
								}
								else
								{
									if((zahl==6)&&(bfeld7==0))
									{
										feld7='O';
										bfeld7=1;
										korrekt=1;
									}
									else
									{
										if((zahl==7)&&(bfeld8==0))
										{
											feld8='O';
											bfeld8=1;
											korrekt=1;
										}
										else
										{
											if((zahl==8)&&(bfeld9==0))
											{
												feld9='O';
												bfeld9=1;
												korrekt=1;
											}
											else
											{
												korrekt=0;
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}while(korrekt==0);
	}


							//Funktion mit der das Spielfeld ausgegeben wird !!!//
//---------------------------------------------------------------------------------------------------------------------------------

	public static void spielfeldAusgeben ()
	{
		System.out.print("Tic-Tac-Toe\n\n");
		System.out.print("\n\t1 2 3\n");
		System.out.print("1.\t"+feld1+"|"+feld2+"|"+feld3+"\n");
		System.out.print("\t-+-+-\n");
		System.out.print("2.\t"+feld4+"|"+feld5+"|"+feld6+"\n");
		System.out.print("\t-+-+-\n");
		System.out.print("3.\t"+feld7+"|"+feld8+"|"+feld9+"\n\n\n\n\n");


	}//end of Funktion "spielfedAusgeben"//


													//MAIN//
//---------------------------------------------------------------------------------------------------------------------------------
	public static void main (String args[])
	{
		//Vorspann bevor das Spiel beginnt !!//
		Konsole kons = new Konsole();
		kons.gotoXY(25,2);
		System.out.print("Welcome to TIC TAC TOE");
		kons.sleep(1500);
		kons.cls();
		kons.gotoXY(30,2);
		System.out.print("Are You Ready???");
		kons.sleep(2500);
		kons.cls();
		kons.gotoXY(38,5);
		System.out.print("3");
		kons.sleep(300);
		kons.cls();
		kons.gotoXY(38,5);
		System.out.print("2");
		kons.sleep(300);
		kons.cls();
		kons.gotoXY(38,5);
		System.out.print("1");
		kons.sleep(300);
		kons.cls();
		kons.gotoXY(35,5);
		System.out.print("FIGHT!!!");
		kons.sleep(1300);
		kons.cls();

		//Das Spiel beginnt"!!/
		do
		{
		spielerZieht();
		spielfeldAusgeben();
		ueberpruefen();
		kons.sleep(600);
		sieger();
		kons.cls();
		computerZieht();
		spielfeldAusgeben();
		ueberpruefen();
		kons.sleep(600);
		sieger();
		ueberpruefen();
		}while(spielZustand==0);//end of do/while//
	}//end of main
}//end of class
```


----------



## Templon (1. Sep 2008)

Ich mag die Funktion ueberpruefen() =)

Naja wie schon gesagt wurde, wäre das ganze ziemlich viel einfacher mir Arrays. 

Warum dein Lehrer nicht will, dass ihr schon im voraus etwas neues lernen/anwenden möchtet, finde ich ein bisschen komisch...


----------



## Guest (1. Sep 2008)

hab nochma ne frage.
wenn der angibt wer gewonnen hat . Wie kann ich machen das er nachdem er kurz wartet das fenster schließt?
gibts da irgendwas für?


----------



## Landei (2. Sep 2008)

Warte doch einfach auf eine Tasteneingabe, um das Fenster zu schließen. Man kann natürlich auch Thread.sleep(zeitInMillisekunden) verwenden, um zu warten


----------



## Bene1991 (2. Sep 2008)

ne er soll nich warten sondern das programm ganz beenden


----------



## Landei (2. Sep 2008)

Keine Ahnung, wie diese komische "Konsole" programmiert ist, aber mit System.exit(0) lässt sich normalerweise alles abschießen.


----------



## Marco13 (2. Sep 2008)

Was mich beunruhigt ist einerseits, dass das hier in dieser Form gepostet wurde, viel mehr aber noch, dass sicher irgendwann jemand nach "Java Tic Tac Toe" websucht, das dann hier findet, und ungefragt übernimmt   

Also - wenn der Lehrer irgendwelche Anforderungen und/oder Einschränkungen vorgegeben hat, die so ein Prgogramm "erzwingen", kann man's nicht ändern. Aber für alle anderen Fälle:

*Genau SO sollte man NICHT Programmieren!!!*


----------



## Landei (2. Sep 2008)

Ja, da kräuseln sich mir die Fußnägel. Der Lehrer sollte zu zehn Jahren Cobol ohne Bewährung verurteilt werden...


----------



## Guest (11. Sep 2008)

Ich würde von 0 an neu anfangen! Das heißt sich nochmal alles überlegen und neu schreiben, denn so wird das Programm höchstens langsam und vorallem Fehleranfällig!

Eigentlich ist es gar nicht so schwer, du brauchst nur ein Array (zB. spielfeld[][]) und abwechselnd macht jeder Spieler (für den Anfang ohne Computergegner und ohne KI (Künstliche Intellegenz)) einen Zug, dabei solltest du prüfen ob dieser gültig ist und ob dann nicht schon ein Spieler gewonnen hat.

Dies würde ich mir am Anfang vornehmen, später kannst du dann Runden zählen wer öfters gewinnt, einen Computergegner implementieren,...


MfG
xiix


----------

