diff --git a/Praktikum/VINF_TicTacToe/.classpath b/Praktikum/VINF_TicTacToe/.classpath new file mode 100644 index 0000000000000000000000000000000000000000..a391d07e4a752822b28386d466ffbce147e6fd45 --- /dev/null +++ b/Praktikum/VINF_TicTacToe/.classpath @@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="UTF-8"?> +<classpath> + <classpathentry kind="src" path="src"/> + <classpathentry kind="src" path="test"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/> + <classpathentry kind="output" path="bin"/> +</classpath> diff --git a/Praktikum/VINF_TicTacToe/.gitignore b/Praktikum/VINF_TicTacToe/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..ae3c1726048cd06b9a143e0376ed46dd9b9a8d53 --- /dev/null +++ b/Praktikum/VINF_TicTacToe/.gitignore @@ -0,0 +1 @@ +/bin/ diff --git a/Praktikum/VINF_TicTacToe/.project b/Praktikum/VINF_TicTacToe/.project new file mode 100644 index 0000000000000000000000000000000000000000..a3275a04ce1f416100dc7cdf8cea41c812e91c96 --- /dev/null +++ b/Praktikum/VINF_TicTacToe/.project @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>VINF_TicTacToe</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>org.eclipse.jdt.core.javabuilder</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>org.eclipse.jdt.core.javanature</nature> + </natures> +</projectDescription> diff --git a/Praktikum/VINF_TicTacToe/.settings/org.eclipse.jdt.core.prefs b/Praktikum/VINF_TicTacToe/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000000000000000000000000000000000000..bb35fa0a87b032ee9d0b128004c1edbd464f07bf --- /dev/null +++ b/Praktikum/VINF_TicTacToe/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,11 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/Praktikum/VINF_TicTacToe/src/tictactoePraktikum/TicTacToe.java b/Praktikum/VINF_TicTacToe/src/tictactoePraktikum/TicTacToe.java new file mode 100644 index 0000000000000000000000000000000000000000..df35419c8f1eebcd7d26ba947918ff31781628f2 --- /dev/null +++ b/Praktikum/VINF_TicTacToe/src/tictactoePraktikum/TicTacToe.java @@ -0,0 +1,244 @@ +package tictactoePraktikum; + +/**TicTacToe Spiel + * + * @author Prof. Dr. Christian Weidauer (Hochschule Bochum) + * @author Volker Sch�rmann (Hochschule Bochum) + * Vertiefung Informatik + * + */ +public class TicTacToe { + + private TicTacToeUI ui; + + final static int ENTSCHIEDEN = 1; + final static int UNENTSCHIEDEN = 2; + final static int LAEUFT = 3; + final static int ABGEBROCHEN = 4; + + private char[] spielerZeichen = new char[2]; + private char[][] spielbrett = new char [3][3]; + + + public TicTacToe(TicTacToeUI ui){ + + this.ui = ui; + + spielerZeichen[0] = 'X'; + spielerZeichen[1] = 'O'; + + resetSpiel(); + } + + /** + * Setzt das Spielfeld wieder in den Ursprungszustand. + */ + void resetSpiel(){ + + for(char zeile[]: spielbrett ) + { + for (int i = 0; i < zeile.length; i++) { + zeile[i] = ' '; + } + } + } + + /** + * Zuf�llige Ermittlung wer das Spiel beginnt. + * @return Array-Index des Spielers, der beginnt + */ + static int getStartSpieler(){ + + return (int) Math.round( Math.random()); + } + + /** + * Bestimmt den Spieler, der als n�chstes am Zug ist. + * @param aktuellerSpieler Spieler, der aktuell am Zug ist + * @return Array-Index des n�chsten Spielers + */ + int getNaechstenSpieler(int aktuellerSpieler){ + + return (aktuellerSpieler + 1) % 2; + } + + /** + * Testet, ob das adressierte Feld im Array vorkommt und ob es frei ist. + * @param zeile Zeile des Zuges + * @param spalte Spalte des Zuges + * @return true, falls es vorkommt und frei ist - falls es nicht vorkommt oder belegt ist + */ + boolean isGueltig(int zeile, int spalte){ + + if(spalte>2||spalte<0 + ||zeile>2||zeile<0 + ||spielbrett[zeile] [spalte] != ' '){ + + return false; + } + else{ + + return true; + } + } + + /** + * Ist das Spiel unentschieden? + * @return true, falls unentschieden + */ + boolean isUnentschieden(){ + + boolean unentschieden = true; + + for (char[] zeile:spielbrett) { + for(char spielfeld:zeile){ + + if(spielfeld == ' ') + unentschieden = false; + } + } + + return unentschieden; + } + + /** + * Bestimmt den aktuellen Spielzustand + * @return + * LAEUFT: Weitere Spielz�ge m�glich + * UNENTSCHIEDEN: Spiel ohne Sieger beendet + * ENTSCHIEDEN: Es gibt einen Gewinner + */ + int getSpielzustand(){ + + int status = LAEUFT; + + if (getGewinner() != ' '){ + + return ENTSCHIEDEN; + } + + if (isUnentschieden()){ + + return UNENTSCHIEDEN; + } + + return status; + } + + /** + * F�hrt f�r den �bergebenen Spieler einen Spielzug durch. + * @param aktuellerSpieler Spieler, der aktuell am Zug ist + * @return Spielzustand + */ + int spielzug(int aktuellerSpieler){ + + int aktuelleZeile = 0; + int aktuelleSpalte= 0; + do { + + String zugEingabe = ui.getZugeingabe(spielbrett, spielerZeichen[aktuellerSpieler]); + + if (zugEingabe.equalsIgnoreCase("a")){ + + return ABGEBROCHEN; + } + + try{ + aktuelleZeile = Integer.parseInt(zugEingabe)/10; + aktuelleSpalte= Integer.parseInt(zugEingabe)%10; + } + catch (NumberFormatException nfe){} + + + } while (!isGueltig(aktuelleZeile, aktuelleSpalte)); + + spielbrett[aktuelleZeile][aktuelleSpalte] = spielerZeichen[aktuellerSpieler]; + + return getSpielzustand(); + } + + /** + * F�hrt ein komplettes Spiel durch. + * @return Spielzustand + */ + public int spiel(int startSpieler) { + + resetSpiel(); + + int spielzustand = LAEUFT; + + int aktuellerSpieler = startSpieler; + + do { + + spielzustand = spielzug(aktuellerSpieler); + + aktuellerSpieler = getNaechstenSpieler(aktuellerSpieler); + + + } while (spielzustand == LAEUFT); + + return spielzustand; + } + + /** + * Pr�ft ob es einen Gewinner gibt und wer es ist. + * @return Zeichen des Gewinners oder Leerzeichen + */ + public char getGewinner(){ + + char gewinner = ' '; + + for(char spieler: spielerZeichen ){ + + for(int i=0; i<3; i++){ + + if ((spielbrett[i][0] + spielbrett[i][1] + + spielbrett[i][0] == 3*spieler) || + (spielbrett[0][i] + spielbrett[1] [i] + + spielbrett[i][2] == 3*spieler)|| + (spielbrett[0][0] + spielbrett[1][1] + spielbrett[2][2] == + 3*spieler) + ||(spielbrett[2][0] + spielbrett[1][1] + spielbrett[0][2] == + 3*spieler) + ) { + + gewinner = spieler; + break; + } + } + + } + + return gewinner; + } + + /** + * Gibt das Spielbrett zur�ck + * @return Spielbrett + */ + public char[][] getSpielbrett() { + return spielbrett; + } + + /** + * Setzt das Spielbrett auf die �bergebenen Werte. + * @param spielbrett + */ + public void setSpielbrett(char[][] spielbrett) { + this.spielbrett = spielbrett; + } +} + + + + + + + + + + + + + diff --git a/Praktikum/VINF_TicTacToe/src/tictactoePraktikum/TicTacToeApp.java b/Praktikum/VINF_TicTacToe/src/tictactoePraktikum/TicTacToeApp.java new file mode 100644 index 0000000000000000000000000000000000000000..14c3d67b798f54e86d1633f3a680c0a19923997d --- /dev/null +++ b/Praktikum/VINF_TicTacToe/src/tictactoePraktikum/TicTacToeApp.java @@ -0,0 +1,81 @@ +package tictactoePraktikum; +import java.awt.Font; + +import javax.swing.JOptionPane; +import javax.swing.UIManager; + +/**Applikation und Benutzerschnittstelle von TicTacToe + * + * @author Prof. Dr. Christian Weidauer (Hochschule Bochum) + * @author Volker Sch�rmann (Hochschule Bochum) + * Vertiefung Informatik + * + */ +public class TicTacToeApp implements TicTacToeUI{ + + /** + * Start und Auswertung des Spiels + * @param args + */ + public static void main(String[] args) { + + UIManager.put("OptionPane.messageFont", new Font(Font.MONOSPACED, Font.PLAIN, 15)); + + Spielserie: + do { + + TicTacToe ttt = new TicTacToe(new TicTacToeApp()); + + switch (ttt.spiel(TicTacToe.getStartSpieler())) { + case TicTacToe.UNENTSCHIEDEN: + JOptionPane.showMessageDialog(null, "Gratulation!\n" + +"Sie haben unentschieden gespielt!"); + break; + + case TicTacToe.ENTSCHIEDEN: + JOptionPane.showMessageDialog(null, "Herzlichen Gl�ckwunsch!\n" + + ttt.getGewinner()+", Sie haben gewonnen!"); + break; + + case TicTacToe.ABGEBROCHEN: + JOptionPane.showMessageDialog(null, "Abbruch!"); + break Spielserie; + } + } while (true); + } + + /** + * Grafische Benutzereingabe + */ + @Override + public String getZugeingabe(char[][] spielbrett, char aktuellerSpieler) { + + String ausgabe = "+-+-+-+\n"; + for (char[] zeile:spielbrett){ + for (char spielfeld:zeile) { + ausgabe += "|" + spielfeld; + } + ausgabe += "|\n+-+-+-+\n"; + } + + ausgabe += aktuellerSpieler + ", bitte Zug eingeben!" + + "\n(Zug: <Zeile><Spalte>)"; + + String zugEingabe = JOptionPane.showInputDialog(ausgabe); + + return zugEingabe; + } +} + + + + + + + + + + + + + diff --git a/Praktikum/VINF_TicTacToe/src/tictactoePraktikum/TicTacToeUI.java b/Praktikum/VINF_TicTacToe/src/tictactoePraktikum/TicTacToeUI.java new file mode 100644 index 0000000000000000000000000000000000000000..9bd4522eaa18640e07d7dd196f9d31bc9283952f --- /dev/null +++ b/Praktikum/VINF_TicTacToe/src/tictactoePraktikum/TicTacToeUI.java @@ -0,0 +1,19 @@ +package tictactoePraktikum; + +/**Schnittstelle f�r das User Interface von TicTacToe + * + * @author Prof. Dr. Christian Weidauer (Hochschule Bochum) + * @author Volker Sch�rmann (Hochschule Bochum) + * Vertiefung Informatik + * + */ +public interface TicTacToeUI { + + /** + * Benutzerschnittstelle + * @param aktuelles Spielbrett + * @param aktueller Spieler + * @return Eingabe des aktuellen Spielers + */ + public String getZugeingabe(char[][] spielbrett, char aktuellerSpieler); +}