commit 659bfd3fa8991685fda842d25bab52718cb2164c Author: Marc Michalsky Date: Fri Apr 24 23:14:34 2020 +0200 Initial Commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..eec0749 --- /dev/null +++ b/.gitignore @@ -0,0 +1,93 @@ + +# Created by https://www.gitignore.io/api/intellij +# Edit at https://www.gitignore.io/?templates=intellij + +### Intellij ### +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff +.idea/**/workspace.xml +.idea/**/tasks.xml +.idea/**/usage.statistics.xml +.idea/**/dictionaries +.idea/**/shelf + +# Generated files +.idea/**/contentModel.xml + +# Sensitive or high-churn files +.idea/**/dataSources/ +.idea/**/dataSources.ids +.idea/**/dataSources.local.xml +.idea/**/sqlDataSources.xml +.idea/**/dynamic.xml +.idea/**/uiDesigner.xml +.idea/**/dbnavigator.xml + +# Gradle +.idea/**/gradle.xml +.idea/**/libraries + +# Gradle and Maven with auto-import +# When using Gradle or Maven with auto-import, you should exclude module files, +# since they will be recreated, and may cause churn. Uncomment if using +# auto-import. +# .idea/modules.xml +# .idea/*.iml +# .idea/modules +# *.iml +# *.ipr + +# CMake +cmake-build-*/ + +# Mongo Explorer plugin +.idea/**/mongoSettings.xml + +# File-based project format +*.iws + +# IntelliJ +out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Cursive Clojure plugin +.idea/replstate.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +# Editor-based Rest Client +.idea/httpRequests + +# Android studio 3.1+ serialized cache file +.idea/caches/build_file_checksums.ser + +### Intellij Patch ### +# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721 + +# *.iml +# modules.xml +# .idea/misc.xml +# *.ipr + +# Sonarlint plugin +.idea/**/sonarlint/ + +# SonarQube Plugin +.idea/**/sonarIssues.xml + +# Markdown Navigator plugin +.idea/**/markdown-navigator.xml +.idea/**/markdown-navigator/ + +# End of https://www.gitignore.io/api/intellij diff --git a/.idea/artifacts/tictactoe_jar.xml b/.idea/artifacts/tictactoe_jar.xml new file mode 100644 index 0000000..e4c3a6e --- /dev/null +++ b/.idea/artifacts/tictactoe_jar.xml @@ -0,0 +1,8 @@ + + + $PROJECT_DIR$/out/artifacts/tictactoe_jar + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..146ab09 --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..e65fee6 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,9 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..b85d8e1 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/tictactoe.iml b/.idea/tictactoe.iml new file mode 100644 index 0000000..c90834f --- /dev/null +++ b/.idea/tictactoe.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..9d17d96 --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +# Tic Tac Toe +![Beispielbild](img/TicTacToe.png) \ No newline at end of file diff --git a/img/TicTacToe.png b/img/TicTacToe.png new file mode 100644 index 0000000..9da8c59 Binary files /dev/null and b/img/TicTacToe.png differ diff --git a/out/artifacts/tictactoe_jar/tictactoe.jar b/out/artifacts/tictactoe_jar/tictactoe.jar new file mode 100644 index 0000000..e827bf2 Binary files /dev/null and b/out/artifacts/tictactoe_jar/tictactoe.jar differ diff --git a/src/META-INF/MANIFEST.MF b/src/META-INF/MANIFEST.MF new file mode 100644 index 0000000..1d6d292 --- /dev/null +++ b/src/META-INF/MANIFEST.MF @@ -0,0 +1,3 @@ +Manifest-Version: 1.0 +Main-Class: gfn.marc.TicTacToe + diff --git a/src/gfn/marc/CSVDatei.java b/src/gfn/marc/CSVDatei.java new file mode 100644 index 0000000..55bba70 --- /dev/null +++ b/src/gfn/marc/CSVDatei.java @@ -0,0 +1,75 @@ +package gfn.marc; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileWriter; +import java.io.IOException; +import java.util.Scanner; +import java.util.ArrayList; + +public class CSVDatei{ + + // Attribute + private final String pfad; + private final String dateiname; + + + // Konstruktor + public CSVDatei(String pfad, String dateiname) { + this.pfad = pfad; + this.dateiname = dateiname; + } + + // Methode: schreibe() + public void schreibe(ArrayList spieler) throws IOException { + String pfadname = this.pfad + this.dateiname; + File csvDatei = new File(pfadname); + File verzeichnis = csvDatei.getParentFile(); + if (verzeichnis != null) { + if (!verzeichnis.exists()) { + verzeichnis.mkdirs(); + } + } + + FileWriter csvSchreiben = new FileWriter(csvDatei); + + // schreibe Zeile + for (Spieler s : spieler) { + csvSchreiben.append(s.getName()).append(";").append(String.valueOf(s.getPunktestand())).append("\n"); + } + csvSchreiben.flush(); + csvSchreiben.close(); + } + + // Methode: lese() + public ArrayList lese() throws FileNotFoundException { + String pfadname = this.pfad + this.dateiname; + File csvDatei; + + // neues FileObjekt erstellen + csvDatei = new File(pfadname); + + if (csvDatei.exists()) { + Scanner eingabe; + + // neues Scanner-Objekt erstellen + eingabe = new Scanner(csvDatei); + + + // Auslesen der Daten in einer Schleife und Ablegen in einer ArrayList + ArrayList ausgabe = new ArrayList<>(); + int i = 0; + while(eingabe.hasNextLine()){ + String zeile = eingabe.nextLine(); + ausgabe.add(zeile); + i++; + } + + // Verbindung schliessen und ArrayList zurückgeben + eingabe.close(); + return ausgabe; + } + return null; + } + +} diff --git a/src/gfn/marc/Feld.java b/src/gfn/marc/Feld.java new file mode 100644 index 0000000..2be9960 --- /dev/null +++ b/src/gfn/marc/Feld.java @@ -0,0 +1,87 @@ +package gfn.marc; + +import javax.swing.*; + +public class Feld { + private static int feldAnzahl = 0; + private int feldId; + private Rechteck rechteck; + private JLabel label = new JLabel(); + private boolean gesetzt; + private Kreuz kreuz; + private Kreis kreis; + + static { + + } + + // Konstruktor + public Feld(Rechteck rechteck) { + if (feldAnzahl == 9) { + Feld.feldAnzahl = 0; + } + this.rechteck = rechteck; + Feld.feldAnzahl++; + this.feldId = Feld.feldAnzahl; + + // Label Position und Größe des Rechtecks zuweisen + this.label.setBounds((this.rechteck.getPara1() - Spielfeld.KORREKTUR_X), (this.rechteck.getPara2() - + Spielfeld.KORREKTUR_Y), this.rechteck.getPara3(), this.rechteck.getPara4()); + this.label.setVisible(true); + + kreuz = new Kreuz((int) (rechteck.getPara1() + (rechteck.getPara3() * 0.1)), + ((int) (rechteck.getPara2() + (rechteck.getPara4() * 0.1))), + ((int) (rechteck.getPara1() + (rechteck.getPara3() * 0.9))), + ((int) (rechteck.getPara2() + (rechteck.getPara4() * 0.9)))); + + kreis = new Kreis((int) (rechteck.getPara1() + (0.1 * rechteck.getPara3())), + (int) (rechteck.getPara2() + (0.1 * rechteck.getPara4())), + ((int) (rechteck.getPara3() * 0.8)), + ((int) (rechteck.getPara4() * 0.8))); + + } + + public void setZeichen(Form form) { + if (form.getClass() == kreuz.getClass()) { + kreuz.setSichtbar(true); + kreis.setSichtbar(false); + } else { + kreis.setSichtbar(true); + kreuz.setSichtbar(false); + } + gesetzt = true; + + } + + public JLabel getLabel() { + return label; + } + + public Rechteck getRechteck() { + return rechteck; + } + + public Kreuz getKreuz() { + return kreuz; + } + + public void setKreuz(Kreuz kreuz) { + this.kreuz = kreuz; + } + + public Kreis getKreis() { + return kreis; + } + + public void setKreis(Kreis kreis) { + this.kreis = kreis; + } + + public int getFeldId() { + return feldId; + } + + public boolean isGesetzt() { + return gesetzt; + } +} diff --git a/src/gfn/marc/Form.java b/src/gfn/marc/Form.java new file mode 100644 index 0000000..20833b3 --- /dev/null +++ b/src/gfn/marc/Form.java @@ -0,0 +1,64 @@ +package gfn.marc; + +import java.awt.*; + +public abstract class Form { + private int para1; + private int para2; + private int para3; + private int para4; + private boolean sichtbar; + + public Form() { + } + + public Form(int para1, int para2, int para3, int para4) { + this.para1 = para1; + this.para2 = para2; + this.para3 = para3; + this.para4 = para4; + } + + public abstract void paintMe(Graphics2D g); + + public int getPara1() { + return para1; + } + + public int getPara2() { + return para2; + } + + public int getPara3() { + return para3; + } + + public int getPara4() { + return para4; + } + + public boolean isSichtbar() { + return sichtbar; + } + + public void setPara1(int para1) { + this.para1 = para1; + } + + public void setPara2(int para2) { + this.para2 = para2; + } + + public void setPara3(int para3) { + this.para3 = para3; + } + + public void setPara4(int para4) { + this.para4 = para4; + } + + public void setSichtbar(boolean sichtbar) { + this.sichtbar = sichtbar; + } + +} diff --git a/src/gfn/marc/Gewinner.java b/src/gfn/marc/Gewinner.java new file mode 100644 index 0000000..39eb0d4 --- /dev/null +++ b/src/gfn/marc/Gewinner.java @@ -0,0 +1,111 @@ +package gfn.marc; + +public class Gewinner { + private static Spieler spieler; + + public static Spieler ermittleGewinner(Spiel spiel) { + + // Prüfe Horizontale + for (int i = 0; i <= 8; i += 3) { + + if (spiel.getSpielfeld().getFelder()[i].getKreuz().isSichtbar() && + spiel.getSpielfeld().getFelder()[i + 1].getKreuz().isSichtbar() && + spiel.getSpielfeld().getFelder()[i + 2].getKreuz().isSichtbar()) { + Gewinner.spieler = spiel.getSpieler1(); + spiel.getSpieler1().setPunktestand(); + spiel.getSpielfeld().getFelder()[i].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[i + 1].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[i + 2].getRechteck().setGewinnerFeld(true); + break; + } + + if (spiel.getSpielfeld().getFelder()[i].getKreis().isSichtbar() && + spiel.getSpielfeld().getFelder()[i + 1].getKreis().isSichtbar() && + spiel.getSpielfeld().getFelder()[i + 2].getKreis().isSichtbar()) { + Gewinner.spieler = spiel.getSpieler2(); + spiel.getSpieler2().setPunktestand(); + spiel.getSpielfeld().getFelder()[i].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[i + 1].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[i + 2].getRechteck().setGewinnerFeld(true); + } + } + + // Prüfe Vertikale + for (int i = 0; i < 3; i++) { + if (spiel.getSpielfeld().getFelder()[i].getKreuz().isSichtbar() && + spiel.getSpielfeld().getFelder()[i + 3].getKreuz().isSichtbar() && + spiel.getSpielfeld().getFelder()[i + 6].getKreuz().isSichtbar()) { + Gewinner.spieler = spiel.getSpieler1(); + spiel.getSpieler1().setPunktestand(); + spiel.getSpielfeld().getFelder()[i].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[i + 3].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[i + 6].getRechteck().setGewinnerFeld(true); + break; + } + + + if (spiel.getSpielfeld().getFelder()[i].getKreis().isSichtbar() && + spiel.getSpielfeld().getFelder()[i + 3].getKreis().isSichtbar() && + spiel.getSpielfeld().getFelder()[i + 6].getKreis().isSichtbar()) { + Gewinner.spieler = spiel.getSpieler2(); + spiel.getSpieler2().setPunktestand(); + spiel.getSpielfeld().getFelder()[i].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[i + 3].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[i + 6].getRechteck().setGewinnerFeld(true); + } + + } + + // Prüfe Diagonale + if (spiel.getSpielfeld().getFelder()[0].getKreuz().isSichtbar() && + spiel.getSpielfeld().getFelder()[4].getKreuz().isSichtbar() && + spiel.getSpielfeld().getFelder()[8].getKreuz().isSichtbar()) { + Gewinner.spieler = spiel.getSpieler1(); + spiel.getSpieler1().setPunktestand(); + spiel.getSpielfeld().getFelder()[0].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[4].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[8].getRechteck().setGewinnerFeld(true); + } + + if (spiel.getSpielfeld().getFelder()[0].getKreis().isSichtbar() && + spiel.getSpielfeld().getFelder()[4].getKreis().isSichtbar() && + spiel.getSpielfeld().getFelder()[8].getKreis().isSichtbar()) { + Gewinner.spieler = spiel.getSpieler2(); + spiel.getSpieler2().setPunktestand(); + spiel.getSpielfeld().getFelder()[0].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[4].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[8].getRechteck().setGewinnerFeld(true); + } + + if (spiel.getSpielfeld().getFelder()[2].getKreuz().isSichtbar() && + spiel.getSpielfeld().getFelder()[4].getKreuz().isSichtbar() && + spiel.getSpielfeld().getFelder()[6].getKreuz().isSichtbar()) { + Gewinner.spieler = spiel.getSpieler1(); + spiel.getSpieler1().setPunktestand(); + spiel.getSpielfeld().getFelder()[2].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[4].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[6].getRechteck().setGewinnerFeld(true); + } + + if (spiel.getSpielfeld().getFelder()[2].getKreis().isSichtbar() && + spiel.getSpielfeld().getFelder()[4].getKreis().isSichtbar() && + spiel.getSpielfeld().getFelder()[6].getKreis().isSichtbar()) { + Gewinner.spieler = spiel.getSpieler2(); + spiel.getSpieler2().setPunktestand(); + spiel.getSpielfeld().getFelder()[2].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[4].getRechteck().setGewinnerFeld(true); + spiel.getSpielfeld().getFelder()[6].getRechteck().setGewinnerFeld(true); + } + + return Gewinner.spieler; + + } + + public static Spieler getSpieler() { + return spieler; + } + + public static void setSpieler(Spieler spieler) { + Gewinner.spieler = spieler; + } +} diff --git a/src/gfn/marc/Kreis.java b/src/gfn/marc/Kreis.java new file mode 100644 index 0000000..6865d67 --- /dev/null +++ b/src/gfn/marc/Kreis.java @@ -0,0 +1,22 @@ +package gfn.marc; + +import java.awt.*; + +public class Kreis extends Form { + + public Kreis() { + } + + public Kreis(int para1, int para2, int para3, int para4) { + super(para1, para2, para3, para4); + } + + @Override + public void paintMe(Graphics2D g) { + if (this.isSichtbar()) { + g.setColor(Color.red); + g.setStroke(new BasicStroke(10)); + g.drawOval(this.getPara1(), this.getPara2(), this.getPara3(), this.getPara4()); + } + } +} diff --git a/src/gfn/marc/Kreuz.java b/src/gfn/marc/Kreuz.java new file mode 100644 index 0000000..4865aca --- /dev/null +++ b/src/gfn/marc/Kreuz.java @@ -0,0 +1,24 @@ +package gfn.marc; + +import java.awt.*; + +public class Kreuz extends Form { + + public Kreuz() { + } + + public Kreuz(int para1, int para2, int para3, int para4) { + super(para1, para2, para3, para4); + } + + @Override + public void paintMe(Graphics2D g) { + if (this.isSichtbar()) { + g.setColor(Color.blue); + g.setStroke(new BasicStroke(10)); + g.drawLine(this.getPara1(), this.getPara2(), this.getPara3(), this.getPara4()); + g.drawLine(this.getPara3(), this.getPara2(), this.getPara1(), this.getPara4()); + } + } + +} diff --git a/src/gfn/marc/Rechteck.java b/src/gfn/marc/Rechteck.java new file mode 100644 index 0000000..559d033 --- /dev/null +++ b/src/gfn/marc/Rechteck.java @@ -0,0 +1,44 @@ +package gfn.marc; + +import java.awt.*; + +public class Rechteck extends Form { + private boolean gewinnerFeld = false; + public Rechteck(int para1, int para2, int para3, int para4) { + super(para1, para2, para3, para4); + } + + @Override + public void paintMe(Graphics2D g) { + if (this.isSichtbar()) { + g.setColor(Color.black); + g.setStroke(new BasicStroke(5)); + g.drawRect(this.getPara1(), this.getPara2(), this.getPara3(), this.getPara4()); + } + } + + public void faerbeGruen(Graphics2D g) { + if (this.isGewinnerFeld()) { + g.setColor(Color.green); + g.fillRect(this.getPara1(), this.getPara2(), this.getPara3(), this.getPara4()); + g.setColor(Color.black); + g.setStroke(new BasicStroke(5)); + g.drawRect(this.getPara1(), this.getPara2(), this.getPara3(), this.getPara4()); + } + } + + public void paintId(Graphics g, int i) { + i += 47; + char[] c = {(char) i}; + g.drawChars(c, 0, 1, ((int) (this.getPara1() + (0.5 * this.getPara3()))), + ((int) (this.getPara2() + (0.5 * this.getPara4())))); + } + + public boolean isGewinnerFeld() { + return gewinnerFeld; + } + + public void setGewinnerFeld(boolean gewinnerFeld) { + this.gewinnerFeld = gewinnerFeld; + } +} diff --git a/src/gfn/marc/Speicher.java b/src/gfn/marc/Speicher.java new file mode 100644 index 0000000..424e54c --- /dev/null +++ b/src/gfn/marc/Speicher.java @@ -0,0 +1,53 @@ +package gfn.marc; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.util.ArrayList; + +public class Speicher { + + private static final CSVDatei csv = new CSVDatei(benutzerVerzeichnisErmitteln() + ".TicTacToe" + + File.separator, "TicTacToe_spielstand.csv"); + + public static void spielstaendeEinlesen() throws FileNotFoundException { + ArrayList eintraege = csv.lese(); + + if (eintraege != null && !eintraege.isEmpty()) { + for (String zeile : eintraege) { + String[] eintrag = zeile.split(";"); + if (eintrag.length != 0) { + String spielername = eintrag[0]; + String punktestand = eintrag[1]; + new Spieler(spielername, Integer.parseInt(punktestand)); + } + } + } + } + + public static void spielstaendeSpeichern() throws IOException { + csv.schreibe(Spieler.getSpieler()); + } + + public static String benutzerVerzeichnisErmitteln() { + + String os = System.getProperty("os.name").toLowerCase(); + if (os.contains("win")){ + //Windows + return "C:\\users\\"+ System.getProperty("user.name") +"\\"; + } + else if (os.contains("osx")){ + //OSX + return "/home/" + System.getProperty("user.name" + "/"); + } + else if (os.contains("nix") || os.contains("aix") || os.contains("nux")){ + //Linux/Unix + return "/home/" + System.getProperty("user.name") + "/"; + } else { + System.err.println("Benutzerverzeichnis konnte nicht gefunden werden."); + return ""; + } + } + + +} diff --git a/src/gfn/marc/Spiel.java b/src/gfn/marc/Spiel.java new file mode 100644 index 0000000..afe48c4 --- /dev/null +++ b/src/gfn/marc/Spiel.java @@ -0,0 +1,170 @@ +package gfn.marc; + +import javax.swing.*; +import java.awt.*; + +public class Spiel { + + private static Spieler spieler1; + private static Spieler spieler2; + private Frame f; + private Spielfeld spielfeld; + + + Spiel(Frame f, Spielfeld spielfeld) throws InterruptedException { + + this.f = f; + + // Spielernamen festlegen vor erstem Spiel + if (spieler1 == null || spieler2 == null) { + boolean neuerSpieler1 = false; + + // Eingebdialog: Name Spieler1 + String eingabe = ""; + while (true) { + if (Spieler.getSpieler().size() > 1) { + eingabe = JOptionPane.showInputDialog(f, "Wie soll Spieler1 heißen?", + Spieler.getSpieler().get(Spieler.getSpieler().size() - 2).getName()); + } else { + eingabe = JOptionPane.showInputDialog(f, "Wie soll Spieler1 heißen?", + "Spieler1"); + } + if (eingabe == null || !eingabe.contains(";")) { + break; + } else { + JOptionPane.showMessageDialog(null, + "Der Spielername darf kein Semikolon enthalten"); + } + } + // Wenn der eingegebene Spielername vorhanden ist + if ( eingabe != null && !eingabe.equals("")) { + for (Spieler spieler : Spieler.getSpieler()) { + if (spieler != null) { + if (eingabe.equals(spieler.getName())) { + spieler1 = spieler; + spieler1.setForm(new Kreuz()); + break; + } + } + } + // Wenn kein Spielername eingegeben wurde + } else { + spieler1 = new Spieler(); + spieler1.setForm(new Kreuz()); + spieler1.setName("Spieler1"); + } + // Wenn ein neuer Spielername eingegeben wurde + if (spieler1 == null) { + spieler1 = new Spieler(); + spieler1.setForm(new Kreuz()); + spieler1.setName(eingabe); + neuerSpieler1 = true; + } + + // Eingebdialog: Name Spieler2 + while (true) { + if (neuerSpieler1 && Spieler.getSpieler().size() > 1) { + eingabe = JOptionPane.showInputDialog(f, "Wie soll Spieler2 heißen?", + "Spieler2"); + } else if (Spieler.getSpieler().size() > 1) { + eingabe = JOptionPane.showInputDialog(f, "Wie soll Spieler2 heißen?", + Spieler.getSpieler().get(Spieler.getSpieler().size() - 1).getName()); + } else { + eingabe = JOptionPane.showInputDialog(f, "Wie soll Spieler2 heißen?", + "Spieler2"); + } + if (eingabe == null || !eingabe.contains(";")) { + break; + } else { + JOptionPane.showMessageDialog(null, + "Der Spielername darf kein Semikolon enthalten"); + } + } + + // Wenn der eingegebene Spielername vorhanden ist + if (eingabe != null && !eingabe.equals("")) { + for (Spieler spieler : Spieler.getSpieler()) { + if (spieler != null) { + if (eingabe.equals(spieler.getName())) { + spieler2 = spieler; + spieler2.setForm(new Kreis()); + break; + } + } + } + // Wenn kein Spielername eingegeben wurde + } else { + spieler2 = new Spieler(); + spieler2.setForm(new Kreis()); + spieler2.setName("Spieler2"); + } + // Wenn ein neuer Spielername eingegeben wurde + if (spieler2 == null) { + spieler2 = new Spieler(); + spieler2.setForm(new Kreis()); + spieler2.setName(eingabe); + } + } + +// Neues Spielfeld anlegen + this.spielfeld =spielfeld; + + +} + + public boolean spielen() { + + // Züge durchführen + try { + Zug zug = new Zug(); + // Zufälliger Spieler startet + double startSpieler = Math.random(); + while (Gewinner.ermittleGewinner(this) == null && Zug.getZugNummer() < 9) { + if (Zug.getZugNummer() % 2 == 0) { + if (startSpieler <= 0.5d) { + Zug.macheZug(spieler1); + } else { + Zug.macheZug(spieler2); + } + } else { + if (startSpieler > 0.5d) { + Zug.macheZug(spieler1); + } else { + Zug.macheZug(spieler2); + } + } + } + f.repaint(); + Thread.sleep(500); + f.setTitle(Spiel.spieler1.getName() + ": " + Spiel.spieler1.getPunktestand() + " | " + + Spiel.spieler2.getName() + ": " + Spiel.spieler2.getPunktestand()); + if (Gewinner.getSpieler() == null) { + // Noch ein Spiel? + int auswahl = JOptionPane.showOptionDialog(f, "Unentschieden!\nNoch ein Spiel?", "Tic Tac Toe", JOptionPane.YES_NO_OPTION, + JOptionPane.QUESTION_MESSAGE, null, null, null); + return auswahl != JOptionPane.NO_OPTION; + } else { + // Noch ein Spiel? + int auswahl = JOptionPane.showOptionDialog(f, Gewinner.getSpieler().getName() + " hat gewonnen!\nNoch ein Spiel?", "Tic Tac Toe", JOptionPane.YES_NO_OPTION, + JOptionPane.QUESTION_MESSAGE, null, null, null); + return auswahl != JOptionPane.NO_OPTION; + } + } catch (InterruptedException ie) { + System.err.println("Da ist was schief gelaufen!"); + } + return false; + } + + + public Spielfeld getSpielfeld() { + return spielfeld; + } + + public Spieler getSpieler1() { + return spieler1; + } + + public Spieler getSpieler2() { + return spieler2; + } +} diff --git a/src/gfn/marc/Spieler.java b/src/gfn/marc/Spieler.java new file mode 100644 index 0000000..84569a6 --- /dev/null +++ b/src/gfn/marc/Spieler.java @@ -0,0 +1,52 @@ +package gfn.marc; + +import java.util.ArrayList; + +public class Spieler { + + private static ArrayList spieler = new ArrayList<>(); + + private String name; + private Form zeichen; + private int punktestand; + + // Konstruktor zum erzeugen der Spieler im aktuellen Spiel + public Spieler() { + Spieler.spieler.add(this); + } + + // Konstruktor zum Laden der Spieler*innen aus dem Speicher + public Spieler(String name, int punktestand) { + this.name = name; + this.punktestand = punktestand; + Spieler.spieler.add(this); + } + + public String getName() { + return this.name; + } + + public void setName(String name) { + this.name = name; + } + + public Form getForm() { + return zeichen; + } + + public void setForm(Form form) { + this.zeichen = form; + } + + public int getPunktestand() { + return punktestand; + } + + public void setPunktestand() { + this.punktestand++; + } + + public static ArrayList getSpieler() { + return spieler; + } +} diff --git a/src/gfn/marc/Spielfeld.java b/src/gfn/marc/Spielfeld.java new file mode 100644 index 0000000..b14bd96 --- /dev/null +++ b/src/gfn/marc/Spielfeld.java @@ -0,0 +1,69 @@ +package gfn.marc; + +import java.awt.*; + +import static gfn.marc.TicTacToe.fensterGroesse; +import static gfn.marc.TicTacToe.DEBUG; + +public class Spielfeld { + + final static int KORREKTUR_X = 0; // Korrektur der Spielfeldposition auf X Achse + final static int KORREKTUR_Y = 25; // Korrektur der Spielfeldposition auf Y Achse + + private int quadrant = fensterGroesse / 3; + private Frame f; + private Feld[] felder = new Feld[9]; + private boolean spielfeldExistiert; + + // Unterteilung des Spielfelds in rechteckige Felder + public Spielfeld(Frame f) { + this.f = f; + int k = 0; + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { + felder[k] = new Feld(new Rechteck(((this.quadrant * j) + KORREKTUR_X), (KORREKTUR_Y + (this.quadrant * i)), + this.quadrant, this.quadrant)); + k++; + } + } + } + + // zeichne Spielfeld + public void zeichneSpielfeld(Graphics2D g) { + + for (Feld feld : this.felder) { + feld.getRechteck().setSichtbar(true); + feld.getRechteck().paintMe(g); + // Zahlen auf Felder einblenden, wenn Debug-Mode aktiviert ist + this.f.add(feld.getLabel()); + if (DEBUG) { + feld.getRechteck().paintId(g, feld.getFeldId()); + } + } + } + + // Spielfeld äufräumen + public void aufraeumen() { + + felder = null; + this.f = null; + + } + + public Feld[] getFelder() { + return felder; + } + + public Frame getF() { + return f; + } + + public boolean isSpielfeldExistiert() { + return spielfeldExistiert; + } + + public void setSpielfeldExistiert(boolean spielfeldExistiert) { + this.spielfeldExistiert = spielfeldExistiert; + } +} + diff --git a/src/gfn/marc/TicTacToe.java b/src/gfn/marc/TicTacToe.java new file mode 100644 index 0000000..28dba34 --- /dev/null +++ b/src/gfn/marc/TicTacToe.java @@ -0,0 +1,116 @@ +package gfn.marc; + +import javax.swing.*; +import java.awt.*; +import java.awt.event.*; +import java.io.IOException; + +import static gfn.marc.Spielfeld.KORREKTUR_X; +import static gfn.marc.Spielfeld.KORREKTUR_Y; + + +public class TicTacToe extends JFrame { + + static Frame f; + static int fensterGroesse; + static Spielfeld spielfeld; + static Spiel spiel; + static boolean DEBUG = false; + + public static void main(String[] args) throws IOException { + + // Laden der Spielstände + Speicher.spielstaendeEinlesen(); + + // Eingabedialog: Fenstergröße + String eingabe = ""; + while (true) { + eingabe = JOptionPane.showInputDialog(f, "Wie groß soll das Spielfeld sein? (in Pixel)", + "600"); + try { + fensterGroesse = Integer.parseInt(eingabe); + break; + } catch (NumberFormatException nfe) { + JOptionPane.showMessageDialog(null, "Die Eingabe muss eine Zahl sein!"); + } + } + + + // Spiel starten + try { + boolean nochEinSpiel = true; + while (nochEinSpiel) { + + f = new TicTacToe(); + f.setSize((fensterGroesse + KORREKTUR_X), (fensterGroesse + KORREKTUR_Y)); // Fenster Breite und Höhe + f.setLocationRelativeTo(null); + f.setLayout(null); + f.setResizable(false); + f.setTitle("Tic Tac Toe"); // Fenster Titeltext + f.setVisible(true); // Fenster anzeigen + f.addWindowListener(new WindowAdapter() { + public void windowClosing(WindowEvent e) { + try { + Speicher.spielstaendeSpeichern(); + } catch (IOException ex) { + ex.printStackTrace(); + } + System.exit(0); // sofortiges Programmende + } + }); + + spielfeld = new Spielfeld(f); + spiel = new Spiel(f, spielfeld); + nochEinSpiel = spiel.spielen(); + + // aufräumen + spielfeld.aufraeumen(); + Gewinner.setSpieler(null); + spiel = null; + spielfeld = null; + Zug.setZugNummer(0); + f.setVisible(false); + f = null; + } + } catch (InterruptedException ie) { + System.err.println("Da ist was schief gelaufen!"); + } + Speicher.spielstaendeSpeichern(); + System.exit(0); // sofortiges Programmende + + } + + public static Spielfeld getSpielfeld() { + return spielfeld; + } + + public static Frame getF() { + return f; + } + + public void paint(Graphics g) { + + Graphics2D g2 = (Graphics2D) g; + + if (spielfeld != null) { + spielfeld.zeichneSpielfeld(g2); + spielfeld.setSpielfeldExistiert(true); + } + + if (spielfeld != null) { + for (Feld feld : spielfeld.getFelder()) { + feld.getKreuz().paintMe(g2); + feld.getKreis().paintMe(g2); + } + } + + if (spielfeld != null) { + for (Feld feld : spielfeld.getFelder()) { + feld.getRechteck().faerbeGruen(g2); + feld.getKreuz().paintMe(g2); + feld.getKreis().paintMe(g2); + } + } + } + +} \ No newline at end of file diff --git a/src/gfn/marc/Zug.java b/src/gfn/marc/Zug.java new file mode 100644 index 0000000..ac7bc12 --- /dev/null +++ b/src/gfn/marc/Zug.java @@ -0,0 +1,136 @@ +package gfn.marc; + +import java.awt.*; +import java.awt.event.MouseEvent; +import java.awt.event.MouseListener; + +public class Zug { + + private static Frame f; + private static Spielfeld spielfeld; + private static int zugNummer = 0; + private static boolean zugLaeuft; + private static CustomMouseListener[] cmls = new CustomMouseListener[9]; + + public Zug() { + Zug.spielfeld = TicTacToe.getSpielfeld(); + Zug.f = TicTacToe.getF(); + createMouseListeners(); + } + + // Zuganzahl hochzählen und Titelleiste setzen + public static void macheZug(Spieler spieler) { + if (zugNummer == 9) { + Zug.zugNummer = 0; + } + Zug.zugNummer++; + f.setTitle(spieler.getName() + " ist dran!"); + Zug.setZugLaeuft(true); + + + // Mouselistener auf Felder setzen, die noch nicht gesetzt wurden + for (int i = 0; i < spielfeld.getFelder().length; i++) { + if (!spielfeld.getFelder()[i].isGesetzt()) { + cmls[i].setSpieler(spieler); + spielfeld.getFelder()[i].getLabel().addMouseListener(cmls[i]); + } + } + + // Auf setzen eines Feldes warten + while (Zug.isZugLaeuft()) { + try { + Thread.sleep(200); + } catch (InterruptedException ie) { + break; + } + } + + // MouseListener von allen Feldern entfernen + for (int i = 0; i < spielfeld.getFelder().length; i++) { + spielfeld.getFelder()[i].getLabel().removeMouseListener(cmls[i]); + } + + } + + public static void createMouseListeners() { + for (int i = 0; i < spielfeld.getFelder().length; i++) { + cmls[i] = new CustomMouseListener(f, spielfeld.getFelder()[i]); + } + } + + public static int getZugNummer() { + return zugNummer; + } + + public static boolean isZugLaeuft() { + return zugLaeuft; + } + + public static void setZugLaeuft(boolean zugLaeuft) { + Zug.zugLaeuft = zugLaeuft; + } + + public static void setF(Frame f) { + Zug.f = f; + } + + public static void setSpielfeld(Spielfeld spielfeld) { + Zug.spielfeld = spielfeld; + } + + public static void setZugNummer(int zugNummer) { + Zug.zugNummer = zugNummer; + } + + public static void setCmls(CustomMouseListener[] cmls) { + Zug.cmls = cmls; + } +} + + +class CustomMouseListener implements MouseListener { + + private Frame f; + private Feld feld; + private Spieler spieler; + + public CustomMouseListener(Frame f, Feld feld) { + this.f = f; + this.feld = feld; + } + + public void setSpieler(Spieler spieler) { + this.spieler = spieler; + } + + // Auf Setzen des Feldes prüfen und ggf. Form zeichnen lassen + @Override + public void mouseClicked(MouseEvent mouseEvent) { + this.feld.setZeichen(spieler.getForm()); + f.repaint(); + Zug.setZugLaeuft(false); + } + + // notwendige Implementierungen ohne weitere Funktion + @Override + public void mousePressed(MouseEvent mouseEvent) { + + } + + @Override + public void mouseReleased(MouseEvent mouseEvent) { + + } + + @Override + public void mouseEntered(MouseEvent mouseEvent) { + + } + + @Override + public void mouseExited(MouseEvent mouseEvent) { + + } +} + +