Final version

Author: dzianis-sudkou

src/Game.effekt

@@ -11,25 +11,28 @@ import src/Generate
 def playGame(): Unit = {
 
   // Returns the chosen Game Mode
-  def chooseGameMode(): GameMode / {WrongInput} = {
-    println("Choose the Game Mode:\n[1 - Local, 2 - vs Computer]:")
+  def chooseGameMode():  GameMode / {WrongInput, ExitGame, PrintRules} = {
+    println("Choose the Game Mode:\n[1 - Local; 2 - vs Computer;  h - Read the rules; q - Exit the game]")
     val side = consoleInput()
     side match {
       case "1" => Local()
       case "2" => Computer()
+      case "h" => do PrintRules(); chooseGameMode()
+      case "q" => do ExitGame(); chooseGameMode()
       case _ =>
         do WrongInput("Invalid Game Mode. Please type '1' or '2'!")
         chooseGameMode()
     }
   }
 
   // Returns the Cell type for the side
-  def chooseSide(): Cell / {WrongInput} = {
+  def chooseSide(): Cell / {WrongInput, ExitGame} = {
     println("Choose the side[X, O]:")
     val side = consoleInput()
     side match {
       case "X" => Cross()
       case "O" => Nought()
+      case "q" => do ExitGame(); chooseSide()
       case _ =>
         do WrongInput("Invalid player type. Please type 'X' or 'O'!")
         chooseSide()
@@ -174,21 +177,15 @@ def playGame(): Unit = {
 
   // MAIN SECTION
 
-  clearScreen()
-
   // Greeting Message
-  println("Welcome to the ULTIMATE TIC-TAC-TOE!")
-  println("Press enter to start the game.")
-
-  consoleInput()
+  printWelcomeScreen()
 
   var play: Bool = true
 
-  var player: Cell = Nought()
+  var player: Cell = Cross()
 
   var gameMode: GameMode = Local()
   while (play) {
-
     try{
       // Choosing a Game Mode
       gameMode = chooseGameMode()
@@ -202,9 +199,14 @@ def playGame(): Unit = {
     } with WrongInput { msg =>
       println(msg)
       resume(())
+    } with ExitGame {
+      play = false
+    } with PrintRules {
+      printRules()
+      resume(())
     }
   }
-  println("Goodbye!")
+  printExitScreen()
 }
 
 

src/Render.effekt

@@ -84,4 +84,68 @@ def printGameScreen(gameBoard: GameBoard, player: Cell): Unit = {
 
   renderBoard(gameBoard.bigBoard)
   newLine()
+}
+
+def printWelcomeScreen(): Unit = {
+  clearScreen()
+  with Formatted::formatting
+  val welcomeScreen: String = """
+   __  ____  ____________  ______  ____________   ________________   _________   ______   __________  ______
+  / / / / / /_  __/  _/  |/  /   |/_  __/ ____/  /_  __/  _/ ____/  /_  __/   | / ____/  /_  __/ __ \/ ____/
+ / / / / /   / /  / // /|_/ / /| | / / / __/      / /  / // /  ______/ / / /| |/ /  ______/ / / / / / __/   
+/ /_/ / /___/ / _/ // /  / / ___ |/ / / /___     / / _/ // /__/_____/ / / ___ / /__/_____/ / / /_/ / /___   
+\____/_____/_/ /___/_/  /_/_/  |_/_/ /_____/    /_/ /___/\____/    /_/ /_/  |_\____/    /_/  \____/_____/   
+                                          
+                                          [enter]
+""".green
+  println("\u001b[10H") // Move the cursor to the middle
+  println(welcomeScreen)
+  consoleInput()
+  ()
+}
+
+def printExitScreen(): Unit = {
+  clearScreen()
+  with Formatted::formatting
+  val exitScreen: String = """
+     ______                ____               __
+    / ____/___  ____  ____/ / /_  __  _____  / /
+   / / __/ __ \/ __ \/ __  / __ \/ / / / _ \/ / 
+  / /_/ / /_/ / /_/ / /_/ / /_/ / /_/ /  __/_/  
+  \____/\____/\____/\__,_/_.___/\__, /\___(_)   
+                               /____/             
+
+                [enter]
+    """.green
+  println("\u001b[10H") // Move the cursor to the middle
+  println(exitScreen)
+  consoleInput()
+  ()
+}
+
+def printRules(): Unit = {
+  clearScreen()
+  val rules: String = """
+    Ultimate Tic-Tac-Toe Rules:
+
+    1. The Board: The game is played on a large Tic-Tac-Toe board
+    composed of 9 smaller Tic-Tac-Toe boards.
+
+    2. Winning a Small Board: Within each small board, standard Tic-Tac-Toe rules apply.
+    The first player to get three in a row (horizontally, vertically, or diagonally) wins that small board.
+
+    3. Winning the Big Board: To win the entire game, a player must win three small boards in a row on the large board.
+
+    4. Where to Play: Your move on the big board is determined by your opponent's previous move. 
+    The small board you must play in next corresponds to the cell number within a small board where your opponent just played.
+    Example: If your opponent plays in cell '7' of a small board, your next move must be in the small board numbered '7' on the big board.
+
+    5. Sent to a Won Board: If your opponent's move sends you to a small board that has already been won (or is a draw), 
+    you can play in any of the other 8 small boards.
+
+    [Enter]
+  """
+  println(rules)
+  consoleInput()
+  clearScreen()
 }

src/lib.effekt

@@ -3,6 +3,8 @@ module src/lib
 import io/console
 
 effect WrongInput(msg: String): Unit
+effect ExitGame(): Unit
+effect PrintRules(): Unit
 
 type GameMode {
   Local()
@@ -27,6 +29,7 @@ type WinBoard {
 
 type SmallBoard = List[Cell]
 type BigBoard = List[SmallBoard]
+
 record GameBoard(bigBoard: BigBoard, smallCopy: SmallBoard)
 
 val Numbers: List[String] = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]