Almost fully implemented Computer play. Now I should go eat. Next step is to handle computer's moves

Author: dzianis-sudkou

src/Generate.effekt

@@ -16,16 +16,18 @@ def generateNewBigBoard(): BigBoards = {
   BigBoards(bigBoard, smallBoard)
 }
 
-def newActiveSmallBoard(bigBoards: BigBoards, number: Int): BigBoards = {
+
+// Makes a new Small Board Active()
+def newActiveSmallBoard(gameBoard: BigBoards, smallBoardNumber: Int): BigBoards = {
   with on[OutOfBounds].panic
 
-  var newBigBoard: BigBoard = bigBoards.bigBoard
-  var newBigBoardSmallCopy: SmallBoard = bigBoards.smallCopy
-  var newSmallBoard: SmallBoard = newBigBoard.get(number - 1)
+  var newBigBoard: BigBoard = gameBoard.bigBoard
+  var newGameBoardSmallCopy: SmallBoard = gameBoard.smallCopy
+  var newSmallBoard: SmallBoard = newBigBoard.get(smallBoardNumber )
 
 
   // Making Active Cell in the Small Copy of the Big Board
-  newBigBoardSmallCopy = newBigBoardSmallCopy.replace(number - 1, Active())
+  newGameBoardSmallCopy = newGameBoardSmallCopy.replace(smallBoardNumber, Active())
 
   // Replacing all the Empty() cells with Active()
   var counter: Int = 0
@@ -38,17 +40,17 @@ def newActiveSmallBoard(bigBoards: BigBoards, number: Int): BigBoards = {
     ()
   }
 
-  newBigBoard = newBigBoard.replace(number - 1, newSmallBoard)
-  BigBoards(newBigBoard, newBigBoardSmallCopy)
+  newBigBoard = newBigBoard.replace(smallBoardNumber, newSmallBoard)
+  BigBoards(newBigBoard, newGameBoardSmallCopy)
 }
 
-def deactivateSmallBoard(bigBoards: BigBoards, number: Int): BigBoards = {
+def deactivateSmallBoard(gameBoard: BigBoards, smallBoardNumber: Int): BigBoards = {
   with on[OutOfBounds].panic
 
-  var newBigBoard: BigBoard = bigBoards.bigBoard
-  var newBigBoardSmallCopy: SmallBoard = bigBoards.smallCopy
+  var newBigBoard: BigBoard = gameBoard.bigBoard
+  var newGameBoardSmallCopy: SmallBoard = gameBoard.smallCopy
 
-  var newSmallBoard: SmallBoard = newBigBoard.get(number - 1)
+  var newSmallBoard: SmallBoard = newBigBoard.get(smallBoardNumber)
   var counter: Int = 0
 
 
@@ -60,56 +62,37 @@ def deactivateSmallBoard(bigBoards: BigBoards, number: Int): BigBoards = {
     counter = counter + 1
     ()
   }
-  newBigBoard = newBigBoard.replace(number - 1, newSmallBoard)
-  BigBoards(newBigBoard, newBigBoardSmallCopy)
+  newBigBoard = newBigBoard.replace(smallBoardNumber, newSmallBoard)
+  BigBoards(newBigBoard, newGameBoardSmallCopy)
 }
 
-def checkNewCell(bigBoards: BigBoards, smallBoardNumber: Int, cellNumber: Int, player: Cell): BigBoards = {
+def checkNewCell(gameBoard: BigBoards, smallBoardNumber: Int, cellNumber: Int, player: Cell): BigBoards = {
   with on[OutOfBounds].panic
 
-  var newBigBoard: BigBoard = bigBoards.bigBoard
-  var newSmallBoard: SmallBoard = newBigBoard.get(smallBoardNumber - 1)
-  newSmallBoard = newSmallBoard.replace(cellNumber - 1, player)
-  newBigBoard = newBigBoard.replace(smallBoardNumber - 1, newSmallBoard)
-  BigBoards(newBigBoard, bigBoards.smallCopy)
+  var newBigBoard: BigBoard = gameBoard.bigBoard
+  var newSmallBoard: SmallBoard = newBigBoard.get(smallBoardNumber)
+  newSmallBoard = newSmallBoard.replace(cellNumber, player)
+  newBigBoard = newBigBoard.replace(smallBoardNumber, newSmallBoard)
+  BigBoards(newBigBoard, gameBoard.smallCopy)
 }
 
 /*
- * Returns true if the Small Board is  free.
+ * Returns true if the cell is  free.
  * False Otherwise
  * Input : BigBoards, SmallBoardNumber, Cell Number
  * Output : Boolean
  */
-def checkAvailableSmallBoard(bigBoards: BigBoards, cellNumber: Int): Bool = {
-  with console
+def checkAvailableCell(smallBoard: SmallBoard, cellNumber: Int): Bool = {
   with on[OutOfBounds].panic
 
-  val cellType: Cell = bigBoards.smallCopy.get(cellNumber - 1)
-
-  cellType match {
+  val cellType: Cell = smallBoard.get(cellNumber)
+    cellType match {
     case Empty() => true
     case Active() => true
     case _ => false
   }
 }
 
-
-/*
- * Returns true if the cell is  free.
- * False Otherwise
- * Input : BigBoards, SmallBoardNumber, Cell Number
- * Output : Boolean
- */
-def checkAvailableCell(bigBoards: BigBoards, smallBoardNumber: Int, cellNumber: Int): Bool = {
-  with on[OutOfBounds].panic
-
-  var newBigBoard: BigBoard = bigBoards.bigBoard
-  var newSmallBoard: SmallBoard = newBigBoard.get(smallBoardNumber - 1)
-  val cellType: Cell = newSmallBoard.get(cellNumber - 1)
-  if (cellType is Active()) true
-  else false
-}
-
 /*
  * Returns true if Current Player has won in this Small Board.
  * False Otherwise
@@ -159,11 +142,79 @@ def checkWinSituation(smallBoard: SmallBoard, player: Cell): WinBoard = {
   win
 }
 
-def fillWinningGameBoard(bigBoards: BigBoards, smallBoardNumber: Int, player: Cell): BigBoards = {
-  var newBigBoard: BigBoard = bigBoards.bigBoard
-  var newBigBoardSmallCopy: SmallBoard = bigBoards.smallCopy
+def fillWinningGameBoard(gameBoard: BigBoards, smallBoardNumber: Int, player: Cell): BigBoards = {
+  var newBigBoard: BigBoard = gameBoard.bigBoard
+  var newGameBoardSmallCopy: SmallBoard = gameBoard.smallCopy
+
+  newBigBoard = newBigBoard.replace(smallBoardNumber, fill(9, player))
+  newGameBoardSmallCopy = newGameBoardSmallCopy.replace(smallBoardNumber, player)
+  BigBoards(newBigBoard, newGameBoardSmallCopy)
+}
+
+def computerPlay(smallBoard: SmallBoard, computer: Cell): Int = {
+  with on[OutOfBounds].panic
+
+  var newSmallBoard: SmallBoard = smallBoard
+  var player: Cell = Cross()
+  if (computer is Cross()) player = Nought()
+  var counter: Int = 0
+  var resultCell: Int = 10
+
+  // Check for a winning move
+  while (counter < 9 && resultCell == 10){
+    if (checkAvailableCell(newSmallBoard, counter)){
+      newSmallBoard = newSmallBoard.replace(counter, computer) // Simulate Computer's move
+      if (checkWinSituation(newSmallBoard, computer) is Win()){
+        resultCell = counter
+      }else{
+        newSmallBoard = newSmallBoard.replace(counter, Active())
+      }
+    }
+    counter = counter + 1
+  }
+
+  counter = 0
+  // Check for a blocking move
+  while (counter < 9 && resultCell == 10){
+    if (checkAvailableCell(newSmallBoard, counter)){
+      newSmallBoard = newSmallBoard.replace(counter, player) // // Simulate Player's move
+      if (checkWinSituation(newSmallBoard, player) is Win()){
+        resultCell = counter
+      }else{
+        newSmallBoard = newSmallBoard.replace(counter, Active())
+      }
+    }
+    counter = counter + 1
+  }
+
+  counter = 0
+  // Choose center if available (strong strategically)
+  if ((checkAvailableCell(newSmallBoard, 4)) && resultCell == 10){
+    resultCell = 4
+  }
+
+  counter = 0
+  // Choose a corner if available
+  [0,2,6,8].foreach { cellPos =>
+  if ((checkAvailableCell(newSmallBoard, cellPos)) && resultCell == 10){
+      resultCell = cellPos
+    }
+  }
+
+  // Choose any available side
+  [1, 3, 5, 7].foreach { cellPos =>
+  if ((checkAvailableCell(newSmallBoard, cellPos)) && resultCell == 10){
+      resultCell = cellPos
+    }
+  }
+  resultCell
+}
 
-  newBigBoard = newBigBoard.replace(smallBoardNumber - 1, fill(9, player))
-  newBigBoardSmallCopy = newBigBoardSmallCopy.replace(smallBoardNumber - 1, player)
-  BigBoards(newBigBoard, newBigBoardSmallCopy)
+def isComputerTurn(currentPlayer: Cell, computer: Cell): Bool = {
+  var pcCross: Bool = false
+  var returnValue: Bool = false
+  if (computer is Cross()) pcCross = true
+  if (currentPlayer is Cross()) if (pcCross) returnValue = true
+  if (currentPlayer is Nought()) if (not(pcCross)) returnValue = true
+  false
 }

src/Stupid.effekt

@@ -11,6 +11,20 @@ import src/Generate
 
 def playGame(): Unit = {
 
+  // Returns the chosen Game Mode
+  def chooseGameMode(): GameMode / {WrongInput} = {
+    println("Choose the Game Mode:\n[1 - 2 Players, 2 - vs Computer]:")
+    val side = consoleInput()
+    side match {
+      case "1" => Local()
+      case "2" => Computer()
+      case _ =>
+        do WrongInput("Invalid Game Mode. Please type '1' or '2'!")
+        chooseGameMode()
+    }
+  }
+
+  // Returns the Cell type for the side
   def chooseSide(): Cell / {WrongInput} = {
     println("Choose the side[X, O]:")
     val side = consoleInput()
@@ -23,69 +37,86 @@ def playGame(): Unit = {
     }
   }
 
-  def chooseSmallBoard(bigBoards: BigBoards): Int / {WrongInput} = {
+
+  // Returns the Small Board Number [0 - 8]
+  def chooseSmallBoard(gameBoard: BigBoards): Int / {WrongInput} = {
     println("Choose the Small Board[1 - 9]:")
     val smallBoardNumber: String = consoleInput()
 
     if (not(any(Numbers) {s => s == smallBoardNumber})) {
       do WrongInput("Invalid input. Please type a number from 1 to 9.")
-      chooseSmallBoard(bigBoards)
+      chooseSmallBoard(gameBoard)
     }
     else {
       with on[WrongFormat].panic
       val smallBoardNumber: Int = toInt(smallBoardNumber)
-      if (checkAvailableSmallBoard(bigBoards, smallBoardNumber)){
-        smallBoardNumber
+      if (checkAvailableCell(gameBoard.smallCopy, smallBoardNumber - 1)){
+        smallBoardNumber - 1
       }else {
         do WrongInput("This Small Board is Already occupied. Please type a number for a valid Small Board.")
-        chooseSmallBoard(bigBoards)
+        chooseSmallBoard(gameBoard)
       }
     }
   }
 
-  def chooseCell(bigBoards: BigBoards, smallBoardNumber: Int): Int / {WrongInput} = {
+  // Returns the chosen Cell inside the board [0 - 8]
+  def chooseCell(gameBoard: BigBoards, smallBoardNumber: Int): Int / {WrongInput} = {
+    with on[OutOfBounds].panic
+
     println("Choose the cell inside your Small Board")
     val cellNumber: String = consoleInput()
     if (not(any(Numbers) {s => s == cellNumber})) {
       do WrongInput("Invalid input. Please type a number from 1 to 9.")
-      chooseCell(bigBoards, smallBoardNumber)
+      chooseCell(gameBoard, smallBoardNumber)
     }else {
       with on[WrongFormat].panic
       val cellNumberInt = toInt(cellNumber)
 
-      if(checkAvailableCell(bigBoards, smallBoardNumber, cellNumberInt)){
-        cellNumberInt
+      if(checkAvailableCell(gameBoard.bigBoard.get(smallBoardNumber), cellNumberInt - 1)){
+        cellNumberInt - 1
       }else{
         do WrongInput("This Cell is Already occupied. Please type a number for a valid cell.")
-        chooseCell(bigBoards, smallBoardNumber)
+        chooseCell(gameBoard, smallBoardNumber)
       }
     }
   }
 
-  def gameLoop(player: Cell): Unit / {WrongInput} = {
+  def gameLoop(player: Cell, gameMode: GameMode): Unit / {WrongInput} = {
     var endGame: Bool = false
 
     var gameBoard: BigBoards = generateNewBigBoard()
     var currentSmallBoard: Int = 10
     var currentCell: Int = 10
+    
+    var computer: Cell = Cross()
+    if (player is Cross()) computer = Nought()
 
-    var currentPlayer: Cell = player
+    var currentPlayer: Cell = Cross()
 
     printGameScreen(gameBoard, player)
 
-    if (currentPlayer is Cross()) {
+    if (player is Cross()) {
       println("You're starting the game!\nChoose the starting Small Board.")
       currentSmallBoard = chooseSmallBoard(gameBoard)
       gameBoard = newActiveSmallBoard(gameBoard, currentSmallBoard)
     } else {
-      println("You're starting the game!\nChoose the starting Small Board.")
-      currentSmallBoard = chooseSmallBoard(gameBoard)
-      gameBoard = newActiveSmallBoard(gameBoard, currentSmallBoard)
+      println("Opponent is starting the game!\nChoose the starting Small Board.")
+      if (gameMode is Computer()){
+        currentSmallBoard = computerPlay(gameBoard.smallCopy, computer)
+        gameBoard = newActiveSmallBoard(gameBoard, currentSmallBoard)
+      }else{
+        currentSmallBoard = chooseSmallBoard(gameBoard)
+        gameBoard = newActiveSmallBoard(gameBoard, currentSmallBoard)
+      }
     }
 
     // INNER GAME LOOP OF ONE GAME
     while (not(endGame)){
       if (currentSmallBoard == 10) {
+        if (isComputerTurn(currentPlayer, computer)){
+          currentSmallBoard = computerPlay(gameBoard.smallCopy, computer)
+          gameBoard = newActiveSmallBoard(gameBoard, currentSmallBoard)
+        }
         printGameScreen(gameBoard, currentPlayer)
         currentSmallBoard = chooseSmallBoard(gameBoard)
         gameBoard = newActiveSmallBoard(gameBoard, currentSmallBoard)
@@ -111,11 +142,6 @@ def playGame(): Unit = {
         }
         case _ => ()
       }
-      // if (checkWinSituation(gameBoard.bigBoard.get(currentSmallBoard - 1), currentPlayer) is Win()){
-      //   println("\nYou won the Small Board!")
-      //   consoleInput()
-      //   gameBoard = fillWinningGameBoard(gameBoard, currentSmallBoard, currentPlayer)
-      // }
 
       // After The Player's Move
       printGameScreen(gameBoard, currentPlayer)
@@ -124,7 +150,7 @@ def playGame(): Unit = {
       consoleInput()
 
       // Change the Current Small Board
-      if (checkAvailableSmallBoard(gameBoard, currentCell)){
+      if (checkAvailableCell(gameBoard.smallCopy, currentCell)){
         gameBoard = deactivateSmallBoard(gameBoard, currentSmallBoard)
         currentSmallBoard = currentCell
         gameBoard = newActiveSmallBoard(gameBoard, currentSmallBoard)
@@ -174,14 +200,19 @@ def playGame(): Unit = {
   var play: Bool = true
 
   var player: Cell = Nought()
+
+  var gameMode: GameMode = Local()
   while (play) {
 
     try{
+      // Choosing a Game Mode
+      gameMode = chooseGameMode()
+
       // Choosing a player side
       player = chooseSide()
 
       // Starting the game
-      gameLoop(player)
+      gameLoop(player, gameMode)
 
     } with WrongInput { msg =>
       println(msg)

src/lib.effekt

@@ -4,16 +4,17 @@ import io/console
 
 effect WrongInput(msg: String): Unit
 
+type GameMode {
+  Local()
+  Computer()
+}
 
 type Cell {
   Empty()
   Active()
-
   Nought()
   Cross()
-  
   Draw()
-
   NewLine()
   Separator()
 }