From 9038f0b283edbbd464ecce8031ee059560fd15ce Mon Sep 17 00:00:00 2001 From: Hanin Aljalab <3009857@stud.hs-mannheim.de> Date: Fri, 11 Oct 2024 13:59:29 +0200 Subject: [PATCH] =?UTF-8?q?Musterl=C3=B6sungen=20zu=20den=20=C3=9Cbungsbl?= =?UTF-8?q?=C3=A4ttern?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .idea/vcs.xml | 6 - .../java/Uebung_01/DecToRoem_Version_01.java | 50 ++++ .../java/Uebung_01/DecToRom_Version_02.java | 217 ++++++++++++++++++ src/main/java/Uebung_02/TicTacToe.java | 130 +++++++++++ src/main/java/Uebung_03/BracketChecker.java | 63 +++++ src/main/java/Uebung_03/Main.java | 37 +++ src/main/java/Uebung_03/Stack.java | 50 ++++ src/main/java/Uebung_04/Board.java | 25 ++ src/main/java/Uebung_04/ComputerPlayer.java | 127 ++++++++++ src/main/java/Uebung_04/Game.java | 102 ++++++++ src/main/java/Uebung_04/HumanPlayer.java | 32 +++ src/main/java/Uebung_04/Main.java | 28 +++ src/main/java/Uebung_04/Player.java | 35 +++ 13 files changed, 896 insertions(+), 6 deletions(-) delete mode 100644 .idea/vcs.xml create mode 100644 src/main/java/Uebung_01/DecToRoem_Version_01.java create mode 100644 src/main/java/Uebung_01/DecToRom_Version_02.java create mode 100644 src/main/java/Uebung_02/TicTacToe.java create mode 100644 src/main/java/Uebung_03/BracketChecker.java create mode 100644 src/main/java/Uebung_03/Main.java create mode 100644 src/main/java/Uebung_03/Stack.java create mode 100644 src/main/java/Uebung_04/Board.java create mode 100644 src/main/java/Uebung_04/ComputerPlayer.java create mode 100644 src/main/java/Uebung_04/Game.java create mode 100644 src/main/java/Uebung_04/HumanPlayer.java create mode 100644 src/main/java/Uebung_04/Main.java create mode 100644 src/main/java/Uebung_04/Player.java diff --git a/.idea/vcs.xml b/.idea/vcs.xml deleted file mode 100644 index 94a25f7..0000000 --- a/.idea/vcs.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/src/main/java/Uebung_01/DecToRoem_Version_01.java b/src/main/java/Uebung_01/DecToRoem_Version_01.java new file mode 100644 index 0000000..9bb819f --- /dev/null +++ b/src/main/java/Uebung_01/DecToRoem_Version_01.java @@ -0,0 +1,50 @@ +package Uebung_01; + +import java.util.Scanner; + +/** + * @author Hanin Aljalab + * Anmerkung: in dieser Version findet nur die Umwandlung von + * Dezimal zu Römisch statt. + * Daher muss die Umwandlung von Römisch zu Dezimal erweitert werden + */ +public class DecToRoem_Version_01 { + public static void main(String[] args) { + + int zahl, position = 0; + + //Übersetzungstabellen für die Zahlenwerte + String[] roemisch = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", + "X", "IX", "V", "IV", "I"}; + + int[] arabisch = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}; + + //"Verbindung" zur Tastatur + Scanner input = new Scanner(System.in); + + System.out.println("Konvertierung Dezimal -> Römisch"); + + //Eingabe von x über die Tastatur einlesen + System.out.println("Eingabe von x (1 <= x <= 3999): "); + zahl = input.nextInt(); + + //Umwandlung + //Fehleingaben abfragen + if (zahl < 1 || zahl > 3999) { + System.out.println("Eingabe liegt außerhalb des zulässigen Bereichs!"); + } else { + System.out.println("Ausgabe: "); + // Die arabischen Zahlenwert-Entsprechungen von oben nach unten arbeiten + while (zahl > 0 && position < arabisch.length) { + if (zahl >= arabisch[position]) { // Anpassung der Bedingung + zahl -= arabisch[position]; + System.out.print(roemisch[position]); // Ausgabe in einer Zeile + } else { + position++; + } + } + System.out.println(); // Neue Zeile nach der Ausgabe + } + input.close(); + } +} \ No newline at end of file diff --git a/src/main/java/Uebung_01/DecToRom_Version_02.java b/src/main/java/Uebung_01/DecToRom_Version_02.java new file mode 100644 index 0000000..4a371f5 --- /dev/null +++ b/src/main/java/Uebung_01/DecToRom_Version_02.java @@ -0,0 +1,217 @@ +package Uebung_01; + +/** + * @author Hanin Aljalab + */ + +import java.util.*; + +public class DecToRom_Version_02 { + + // Methode mit Rückgabewert von der Datentyp int + public static int RomToDez(String rom) { + + int dez = 0; + + for (int i = 0; rom.length() > i; i++) { + + char eingabe = rom.charAt(i); //einzelne String Zeichen ausselen + char zeichen; + + if (i + 1 != rom.length()) { + + zeichen = rom.charAt(i + 1); + + // Subtraktion + if (eingabe == 'I' && (zeichen == 'V' || zeichen == 'X' || zeichen == 'L' || zeichen == 'C' + || zeichen == 'D' || zeichen == 'M')) { + + dez = dez - 1; + continue; // Wenn das zutrifft, wird die aktuelle Durchlauf der Schleife übersprungen und + // der nächsten durchgeführt. + } + + if (eingabe == 'V' + && (zeichen == 'X' || zeichen == 'L' || zeichen == 'C' || zeichen == 'D' || zeichen == 'M')) { + dez = dez - 5; + continue; + } + + if (eingabe == 'X' && (zeichen == 'L' || zeichen == 'C' || zeichen == 'D' || zeichen == 'M')) { + dez = dez - 10; + continue; + } + + if (eingabe == 'L' && (zeichen == 'C' || zeichen == 'D' || zeichen == 'M')) { + dez = dez - 50; + continue; + } + + if (eingabe == 'C' && (zeichen == 'D' || zeichen == 'M')) { + dez = dez - 100; + continue; + } + + if (eingabe == 'D' && zeichen == 'M') { + dez = dez - 500; + continue; + } + } + + switch (eingabe) { + + case 'I': + dez = dez + 1; + break; + + case 'V': + dez = dez + 5; + break; + case 'X': + dez = dez + 10; + break; + case 'L': + dez = dez + 50; + break; + case 'C': + dez = dez + 100; + break; + case 'D': + dez = dez + 500; + break; + case 'M': + dez = dez + 1000; + break; + + } + } + + return dez; + + } + + // Methode mit Rückgabewert von der Datentyp String + public static String DecInRom(int dez) { + + String newRom = ""; + + while (dez > 0) { + + if (dez >= 1000) { + + newRom = newRom + "M"; + dez = dez - 1000; + + } + + else if (dez >= 900) { + newRom = newRom + "CM"; + dez = dez - 900; + } + + else if (dez >= 500) { + + dez = dez - 500; + newRom = newRom + "D"; + } + + else if (dez >= 400) { + newRom = newRom + "CD"; + dez = dez - 400; + } + + else if (dez >= 100) { + dez = dez - 100; + newRom = newRom + "C"; + } + + else if (dez >= 90) { + newRom = newRom + "XC"; + dez = dez - 90; + } + + else if (dez >= 50) { + dez = dez - 50; + newRom = newRom + "L"; + } + + else if (dez >= 40) { + newRom = newRom + "XL"; + dez = dez - 40; + } + + else if (dez >= 10) { + dez = dez - 10; + newRom = newRom + "X"; + } + + else if (dez >= 9) { + newRom = newRom + "IX"; + dez = dez - 9; + } + + else if (dez >= 5) { + dez = dez - 5; + newRom = newRom + "V"; + } + + else if (dez >= 4) { + newRom = newRom + "IV"; + dez = dez - 4; + } + + else if (dez >= 1) { + dez = dez - 1; + newRom = newRom + "I"; + } + + } + + return newRom; + } + + public static void main(String[] args) { + // TODO Auto-generated method stub + + String[] romNumber = { "I", "V", "X", "L", "C", "D", "M" }; + int[] dezNumber = { 1, 5, 10, 50, 100, 500, 1000 }; + + Scanner sc = new Scanner(System.in); + + while (true) { + + System.out.println( + "Was möchten Sie tun? \n Geben Sie 1 oder 2: (1 für Römisch -> Dez und 2 für Dez -> Römisch)"); + String eingabe = sc.nextLine(); + + if (eingabe.equals("1")) { + + System.out.println("Geben Sie ein römischen Zahl ein: "); + String rom = sc.nextLine(); + + int dez = RomToDez(rom); + System.out.println("Der Dezimalzahl lautet: " + dez); + } + + else { + System.out.println("Geben Sie den Dezimalzahl ein:"); + int dez = sc.nextInt(); + sc.nextLine(); + + String newRom = DecInRom(dez); + + System.out.println("Der Römischen Zahl lautet: " + newRom); + + } + + System.out.println("Möchten Sie andere Umrechnung durchführen? \nGeben Sie J/N: "); + eingabe = sc.nextLine(); + if (!eingabe.equals("J")) { + break; + } + } + + System.out.println("Fertig"); + } +} + diff --git a/src/main/java/Uebung_02/TicTacToe.java b/src/main/java/Uebung_02/TicTacToe.java new file mode 100644 index 0000000..5248f3e --- /dev/null +++ b/src/main/java/Uebung_02/TicTacToe.java @@ -0,0 +1,130 @@ +package Uebung_02; + +/** + * @author: Hanin Aljalab + * Tic Tac Toe Game + * + */ + + +import java.util.Random; +import java.util.Scanner; + +public class TicTacToe { + public static void main(String[] args) { + + // Decleration of the variables + char[][] board = {{' ', ' ', ' '}, + {' ', ' ', ' '}, + {' ', ' ', ' '} + }; + int player; + boolean win; + + // Initialize the variables + player = 1; + win = false; + + // creating the "Scanner" + Scanner sc = new Scanner(System.in); + + // Start the game + while (!win && !isBoardFull(board)) { + spielfeldAusgeben(board); + + if (player == 1) { + // Player's turn + spielerZug(board, sc); + } else { + // Computer's turn + computerZug(board); + } + + // Check for a win or draw + win = isWin(board); + if (!win) { + player = (player == 1) ? 2 : 1; // change the player + } + } + + spielfeldAusgeben(board); + + if (win) { + System.out.println("Spieler " + player + " gewinnt!"); + } else { + System.out.println("Unentschieden!"); + } + } + + // print the game board + public static void spielfeldAusgeben(char[][] board) { + for (int i = 0; i < board.length; i++) { + for (int j = 0; j < board[i].length; j++) { + System.out.print(" [" + board[i][j] + "] "); + } + System.out.println(); + } + } + + // + public static void spielerZug(char[][] board, Scanner sc) { + System.out.println("Spieler, geben Sie Ihre Position ein (1-9): "); + int input = sc.nextInt(); + + // Convert input in row and column + int row = (input - 1) / 3; + int col = (input - 1) % 3; + + // Check whether the position is valid and the field is not occupied + if (input >= 1 && input <= 9 && board[row][col] == ' ') { + board[row][col] = 'O'; + } else { + System.out.println("Ungültige Position. Bitte erneut versuchen."); + spielerZug(board, sc); // Recursive call for new input + } + } + + public static void computerZug(char[][] board) { + Random ra = new Random(); + int row, col; + + do { + row = ra.nextInt(board.length); + col = ra.nextInt(board.length); + } while (board[row][col] != ' '); + + board[row][col] = 'X'; + } + + public static boolean isWin(char[][] board) { + // Check for profit in rows, columns and diagonals + for (int i = 0; i < 3; i++) { + // Profit in rows + if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ') { + return true; + } + // Profit in columns + if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ') { + return true; + } + } + // Profit in diagonals + if ((board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != ' ') || (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[0][2] != ' ')) { + return true; + } + return false; + } + + public static boolean isBoardFull(char[][] board) { + // Check whether the pitch is full (draw) + for (int i = 0; i < board.length; i++) { + for (int j = 0; j < board[i].length; j++) { + if (board[i][j] == ' ') { + return false; // There are still empty positions + } + } + } + return true; // All positions have been filled + } +} + diff --git a/src/main/java/Uebung_03/BracketChecker.java b/src/main/java/Uebung_03/BracketChecker.java new file mode 100644 index 0000000..b4b5e67 --- /dev/null +++ b/src/main/java/Uebung_03/BracketChecker.java @@ -0,0 +1,63 @@ +package Uebung_03; + +//Import the scanner class for user input + +public class BracketChecker { + + public void bracketChecker(String expression) { + + //Check the brackets in the expression and output the result + if (checkBrackets(expression)) { + System.out.println("Klammern sind gültig."); + } else { + System.out.println("Klammern sind ungültig."); + } + } + + //Method for checking the brackets in the expression + public boolean checkBrackets(String expression) { + //A stack object is created to check the brackets + Stack stack = new Stack(); + + //Loop runs through each letter of the entered expression + for (int i = 0; i < expression.length(); i++) { + char currentChar = expression.charAt(i); + + //If the current character is an opening bracket, it is added to the stack + if (isOpenBracket(currentChar)) { + stack.push(currentChar); + } + //If the current character is a closing bracket + else if (isCloseBracket(currentChar)) { + //Check whether the stack is empty or whether the closing bracket matches the + //last added opening bracket matches + if (stack.isEmpty() || !isMatchingBracket(stack.pop(), currentChar)) { + return false; + } + } + } + + // Check whether the stack is empty after running the expression + return stack.isEmpty(); + } + + //Method to determine whether the character is an opening bracket + public boolean isOpenBracket(char bracket) { + return bracket == '(' || bracket == '[' || bracket == '{'; + } + + //Method to determine whether the character is a closing bracket + public boolean isCloseBracket(char bracket) { + + return bracket == ')' || bracket == ']' || bracket == '}'; + } + + //Method to determine whether the opening and closing clamps fit together + public boolean isMatchingBracket(char openBracket, char closeBracket) { + return (openBracket == '(' && closeBracket == ')') + || (openBracket == '[' && closeBracket == ']') + || (openBracket == '{' && closeBracket == '}'); + } +} + + diff --git a/src/main/java/Uebung_03/Main.java b/src/main/java/Uebung_03/Main.java new file mode 100644 index 0000000..9477535 --- /dev/null +++ b/src/main/java/Uebung_03/Main.java @@ -0,0 +1,37 @@ +package Uebung_03; + +/** + * Stack + * @author Hanin Aljalab + */ + +import java.util.Scanner; +public class Main { + public static void main(String[] args) { + + //A scanner is created + Scanner scanner = new Scanner(System.in); + //User is requested to enter an expression + System.out.println("Geben Sie einen Ausdruck ein:"); + //The user input is saved in the "expression" variable + String expression = scanner.nextLine(); + + BracketChecker br = new BracketChecker(); + + br.bracketChecker(expression); + br.checkBrackets(expression); + + + Stack stack = new Stack(); + // Place characters on the stack + stack.push('A'); + stack.push('B'); + stack.push('C'); + + // Remove character from stack and output + while (!stack.isEmpty()) { + System.out.println("Pop: " + stack.pop()); + } + + } +} diff --git a/src/main/java/Uebung_03/Stack.java b/src/main/java/Uebung_03/Stack.java new file mode 100644 index 0000000..749b6b8 --- /dev/null +++ b/src/main/java/Uebung_03/Stack.java @@ -0,0 +1,50 @@ +package Uebung_03; + + +public class Stack { + // maximum size of the stack. + private int size = 100; + //A char array that provides the actual storage space for the stack elements. + private char[] stack; + //An index that points to the next available position in the stack array. + private int stackPointer; + + // Constructor: Initializes the empty stack + public Stack() { + stack = new char[size]; + stackPointer = 0; // The stack pointer points to the first element of the array + } + + // Method to add a character to the stack + public void push(char c) { + if (stackPointer < size) { + stack[stackPointer] = c; + stackPointer++; // Increments/Increases the stack pointer after adding + } else { + System.out.println("Stack-Overflow: Der Stack ist voll."); + } + } + + // Method for removing and returning the last character added to the stack + public char pop() { + if (stackPointer > 0) { + stackPointer--; // Decrement the stack pointer before reading + return stack[stackPointer]; + } else { + System.out.println("Stack-Underflow: Der Stack ist leer."); + return '\0'; // '\0' stands for an empty character (null character) + } + } + + // Method to check whether the stack is empty + public boolean isEmpty() { + + return stackPointer == 0; + } + + // Method to check whether the stack is full + public boolean isFull() { + return stackPointer == size; + } +} + diff --git a/src/main/java/Uebung_04/Board.java b/src/main/java/Uebung_04/Board.java new file mode 100644 index 0000000..15f459f --- /dev/null +++ b/src/main/java/Uebung_04/Board.java @@ -0,0 +1,25 @@ +package Uebung_04; + +public class Board { + private char[][] board; + + // Constructor to initialize an empty 3x3 board + public Board() { + board = new char[][]{ + {' ', ' ', ' '}, + {' ', ' ', ' '}, + {' ', ' ', ' '} + }; + } + + // Getters and Setters + public char[][] getBoard() { + return board; + } + + public void setBoard(char[][] board) { + this.board = board; + } +} + + diff --git a/src/main/java/Uebung_04/ComputerPlayer.java b/src/main/java/Uebung_04/ComputerPlayer.java new file mode 100644 index 0000000..61c6bca --- /dev/null +++ b/src/main/java/Uebung_04/ComputerPlayer.java @@ -0,0 +1,127 @@ +package Uebung_04; + +import java.util.Random; + +public class ComputerPlayer extends Player { + private Random random; + + // Constructor + public ComputerPlayer(char symbol) { + super(symbol); + this.random = new Random(); + } + + @Override + public void makeMove(Board board) { + int[] bestMove = getBestMove(board, 10000); // Number of simulations + int + + row = bestMove[0]; + int col = bestMove[1]; + + if (board.getBoard()[row][col] == ' ') { + board.getBoard()[row][col] = symbol; + } else { + System.out.println("Error: Invalid move. Choosing the first available empty space."); + makeRandomMove(board); + } + } + + private int[] getBestMove(Board board, int simulations) { + int[] bestMove = new int[]{-1, -1}; + double bestWinRate = -1; + + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { + if (board.getBoard()[i][j] == ' ') { + double winRate = monteCarlo(board, i, j, simulations); + + if (winRate > bestWinRate) { + bestWinRate = winRate; + bestMove[0] = i; + bestMove[1] = j; + } + } + } + } + + System.out.printf("Best Move: (%d, %d) with Win Rate = %.2f%n", bestMove[0] + 1, bestMove[1] + 1, bestWinRate); + + return bestMove; + } + + private double monteCarlo(Board board, int row, int col, int simulations) { + int winCount = 0; + + for (int k = 0; k < simulations; k++) { + Board copyBoard = copyBoard(board); + copyBoard.getBoard()[row][col] = symbol; + + if (simulateGame(copyBoard)) { + winCount++; + } + } + + return (double) winCount / simulations; + } + + private void makeRandomMove(Board board) { + // Fallback method if no valid moves are found + int row, col; + do { + row = random.nextInt(3); + col = random.nextInt(3); + } while (board.getBoard()[row][col] != ' '); + + board.getBoard()[row][col] = symbol; + } + + private boolean simulateGame(Board board) { + // Check for a win in rows + for (int i = 0; i < 3; i++) { + if (board.getBoard()[i][0] == symbol && + board.getBoard()[i][1] == symbol && + board.getBoard()[i][2] == symbol) { + return true; // Computer wins + } + } + + // Check for a win in columns + for (int j = 0; j < 3; j++) { + if (board.getBoard()[0][j] == symbol && + board.getBoard()[1][j] == symbol && + board.getBoard()[2][j] == symbol) { + return true; // Computer wins + } + } + + // Check for a win in diagonals + if (board.getBoard()[0][0] == symbol && + board.getBoard()[1][1] == symbol && + board.getBoard()[2][2] == symbol) { + return true; // Computer wins + } + + if (board.getBoard()[0][2] == symbol && + board.getBoard()[1][1] == symbol && + board.getBoard()[2][0] == symbol) { + return true; // Computer wins + } + + return false; // No win + } + + private Board copyBoard(Board original) { + Board copy = new Board(); + char[][] originalBoard = original.getBoard(); + char[][] copyBoard = copy.getBoard(); + + for (int i = 0; i < originalBoard.length; i++) { + for (int j = 0; j < originalBoard[i].length; j++) { + copyBoard[i][j] = originalBoard[i][j]; + } + } + + return copy; + } +} diff --git a/src/main/java/Uebung_04/Game.java b/src/main/java/Uebung_04/Game.java new file mode 100644 index 0000000..3f37c17 --- /dev/null +++ b/src/main/java/Uebung_04/Game.java @@ -0,0 +1,102 @@ +package Uebung_04; + +import java.util.Scanner; + +class Game { + private Board board; + private Player player1; + private Player player2; + + // Constructor to initialize the game with two players + public Game(Player player1, Player player2) { + this.board = new Board(); + this.player1 = player1; + this.player2 = player2; + } + + //method to play the game + public void playGame() { + int currentPlayer = 1; + boolean win = false; + + Scanner scanner = new Scanner(System.in); + + while (!win && !isBoardFull()) { + boardDisplay(); + // Determine which player's turn it is + if (currentPlayer == 1) { + player1.makeMove(board); + } else { + player2.makeMove(board); + } + // Check for a win + win = isWin(); + + // Switch to the other player if no win + if (!win) { + currentPlayer = (currentPlayer == 1) ? 2 : 1; + } + } + + // Display the final board + boardDisplay(); + + // Display the result of the game + if (win) { + System.out.println("Spieler " + currentPlayer + " gewinnt!"); + } else { + System.out.println("Unentschieden!"); + } + + scanner.close(); + } + + // Display the current state of the board + public void boardDisplay() { + char[][] currentBoard = board.getBoard(); + for (int i = 0; i < currentBoard.length; i++) { + for (int j = 0; j < currentBoard[i].length; j++) { + System.out.print(" [" + currentBoard[i][j] + "] "); + } + System.out.println(); + } + } + + // Check if there is a win on the current board + public boolean isWin() { + char[][] currentBoard = board.getBoard(); + + // Check rows and columns for a win + for (int i = 0; i < 3; i++) { + if (currentBoard[i][0] == currentBoard[i][1] && currentBoard[i][1] == currentBoard[i][2] && currentBoard[i][0] != ' ') { + return true; + } + + if (currentBoard[0][i] == currentBoard[1][i] && currentBoard[1][i] == currentBoard[2][i] && currentBoard[0][i] != ' ') { + return true; + } + } + // Check diagonals for a win + if ((currentBoard[0][0] == currentBoard[1][1] && currentBoard[1][1] == currentBoard[2][2] && currentBoard[0][0] != ' ') || + (currentBoard[0][2] == currentBoard[1][1] && currentBoard[1][1] == currentBoard[2][0] && currentBoard[0][2] != ' ')) { + return true; + } + + return false; + } + + + // Check if the board is full + public boolean isBoardFull() { + char[][] currentBoard = board.getBoard(); + + for (int i = 0; i < currentBoard.length; i++) { + for (int j = 0; j < currentBoard[i].length; j++) { + if (currentBoard[i][j] == ' ') { + return false; + } + } + } + return true; + } +} diff --git a/src/main/java/Uebung_04/HumanPlayer.java b/src/main/java/Uebung_04/HumanPlayer.java new file mode 100644 index 0000000..a944b4f --- /dev/null +++ b/src/main/java/Uebung_04/HumanPlayer.java @@ -0,0 +1,32 @@ +package Uebung_04; + + +import java.util.Scanner; + +public class HumanPlayer extends Player { + private Scanner scanner; + + // Constructor to set the symbol and initialize a scanner for input + public HumanPlayer(char symbol, Scanner scanner) { + super(symbol); + this.scanner = scanner; + } + + @Override + public void makeMove(Board board) { + System.out.println("Player, enter your position (1-9): "); + int input = scanner.nextInt(); + + // Convert input to row and column + int row = (input - 1) / 3; + int col = (input - 1) % 3; + + // Check whether the position is valid and the field is not occupied + if (input >= 1 && input <= 9 && board.getBoard()[row][col] == ' ') { + board.getBoard()[row][col] = symbol; + } else { + System.out.println("Invalid position. Please try again."); + makeMove(board); // Recursive call for new input + } + } +} diff --git a/src/main/java/Uebung_04/Main.java b/src/main/java/Uebung_04/Main.java new file mode 100644 index 0000000..c587615 --- /dev/null +++ b/src/main/java/Uebung_04/Main.java @@ -0,0 +1,28 @@ +package Uebung_04; + +/** + * Tic Tac Toe + * @author Hanin Aljalab + */ + + +import java.util.Scanner; + + +public class Main { + public static void main(String[] args) { + + //create a scanner + Scanner scanner = new Scanner(System.in); + + // Create players + HumanPlayer humanPlayer = new HumanPlayer('O', scanner); + ComputerPlayer computerPlayer = new ComputerPlayer('X'); + + // Create game + Game game = new Game(humanPlayer, computerPlayer); + + // Play the game + game.playGame(); + } +} diff --git a/src/main/java/Uebung_04/Player.java b/src/main/java/Uebung_04/Player.java new file mode 100644 index 0000000..c7918a0 --- /dev/null +++ b/src/main/java/Uebung_04/Player.java @@ -0,0 +1,35 @@ +package Uebung_04; + + +public class Player { + protected char symbol; + protected int winCount; + protected int loseCount; + + // Constructor to set the player's symbol + public Player(char symbol) { + this.symbol = symbol; + this.winCount = 0; + this.loseCount = 0; + } + + // Getter for symbol + public char getSymbol() { + return symbol; + } + + // Increment win count + public void incrementWinCount() { + winCount++; + } + + // Increment lose count + public void incrementLoseCount() { + loseCount++; + } + + // Abstract method for making a move + public void makeMove(Board board) { + // To be implemented by subclasses + } +} \ No newline at end of file