enfin une game qui marche ...

Connect4_CLI/Connect4_CLI/main.swift

@@ -20,16 +20,33 @@ func read(question: String) -> String {
     }
 }
 
-var board = Board(rowsNb: 6, columnsNb: 7)
+public func display(board: Board) {
-var rules = Connect4Rules(piecesToAlign: 4)
+        var boardString = ""
-var player1: Player = HumanPlayer(rules: rules, color: .red, name: "player1", CLI: read)
-var player2: Player = HumanPlayer(rules: rules, color: .yellow, name: "player2", CLI: read)
 
-while rules.isGameOver(board: board).0 != true {
+    for row in (0..<board.rowNb).reversed() {
-    var move = player1.play()
+        for column in 0..<board.columnNb {
-    while rules.possibleMoves(board: board).contains(move) != true {
+            let token = board[row, column]
-        print("Move invalide en choisir un autre")
+                let emoji: String
-        move = player1.play()
+                switch token {
+                case .red:
+                    emoji = "🔴"  // Rond rouge
+                case .yellow:
+                    emoji = "🟡"  // Rond jaune
+                case .empty:
+                    emoji = "⚪"  // Rond gris (vide)
                 }
-    board[move.row, move.column] = player1.color
+                boardString += emoji + " "
-}
+            }
+            boardString += "\n" // Nouvelle ligne après chaque ligne de la grille
+        }
+        print(boardString)
+    }
+
+var rules = Connect4Rules(piecesToAlign: 4)
+var player1: Player = HumanPlayer(rules: rules, color: .red, name: "Adam", CLI: read)
+var player2: Player = RandomPlayer(rules: rules, color: .yellow, name: "BOT")
+var players = [player1, player2]
+var currentPlayer: Player
+
+var game = Game(rules: rules, players: players)
+game.start(display: display)

Model/Sources/Model/Board.swift

@@ -8,8 +8,8 @@
 import Foundation
 
 public struct Board {
-    let rowNb: Int
+    public let rowNb: Int
-    let columnNb: Int
+    public let columnNb: Int
     var grid: [[Token]]
     
     public init(rowsNb: Int = 6, columnsNb: Int = 7) {

Model/Sources/Model/Connect4Rules.swift

@@ -8,22 +8,20 @@
 import Foundation
 public struct Connect4Rules : Rules {
     
+    private var history: [Move] = []
+    public func nextPlayer(players: [Player]) -> Player {
+        return players[history.count % players.count]
+    }
+    
     let piecesToAlign: Int
     
     public init(piecesToAlign: Int) {
         self.piecesToAlign = piecesToAlign
     }
     
-    public func add(board: inout  Board, position pos: (row: Int, column: Int), token: Token) -> Bool {
+    public mutating func add(board: inout Board, move pos: Move, token: Token) {
-        var currentRowNb = 0;
+        history.append(pos)
-        for var row in board.grid {
+        board[pos.row, pos.column] = token
-            if row[pos.column] != Token.empty && currentRowNb != 0 {
-                row[currentRowNb - 1] = token
-                return true
-            }
-            currentRowNb += 1
-        }
-        return false
     }
     
     public func isGameOver(board: Board) -> (result: Bool, winner: Token) {

Model/Sources/Model/Game.swift

@@ -0,0 +1,36 @@
+//
+//  File.swift
+//  
+//
+//  Created by Adam BONAFOS on 06/02/2025.
+//
+
+import Foundation
+public struct Game {
+    var board = Board(rowsNb: 6, columnsNb: 7)
+    var rules = Connect4Rules(piecesToAlign: 4)
+    var players: [Player]
+    var currentPlayer: Player
+    
+    public init(board: Board = Board(rowsNb: 6, columnsNb: 7), rules: Connect4Rules = Connect4Rules(piecesToAlign: 4), players: [Player]) {
+        self.board = board
+        self.rules = rules
+        self.players = players
+        self.currentPlayer = players[0]
+    }
+
+    public mutating func start(display: (Board) -> Void){
+        while rules.isGameOver(board: board).0 != true {
+            var currentPlayer = rules.nextPlayer(players: players)
+            display(board)
+            print("Au tour de : " + currentPlayer.name)
+            var move = currentPlayer.play(board: board)
+            while rules.possibleMoves(board: board).contains(move) != true {
+                display(board)
+                print("Move invalide en choisir un autre")
+                move = currentPlayer.play(board: board)
+            }
+            rules.add(board: &board, move: move, token: currentPlayer.color)
+        }
+    }
+}

Model/Sources/Model/Player/AIPlayer.swift

@@ -6,5 +6,5 @@
 //
 
 import Foundation
-class AIPlayer : Player {
+public class AIPlayer : Player {
 }

Model/Sources/Model/Player/HumanPlayer.swift

@@ -16,7 +16,7 @@ public class HumanPlayer : Player {
         super.init(rules: rules, color: color, name: name)
     }
 
-    public override func play() -> Move {
+    public override func play(board: Board) -> Move {
         // Demande la colonne à l'utilisateur
         let columnInput = CLI!("Entrez le numéro de la colonne : ")
         guard let column = Int(columnInput) else {

Model/Sources/Model/Player/Player.swift

@@ -7,7 +7,7 @@
 
 import Foundation
 public class Player {
-    var name: String
+    public let name: String
     public let color: Token
     var rules: Rules
     public init(rules: Rules, color: Token, name: String){
@@ -15,7 +15,7 @@ public class Player {
         self.color = color
         self.rules = rules
     }
-    public func play() -> Move {
+    public func play(board: Board) -> Move {
         fatalError("Must override in subclass")
     }
 }

Model/Sources/Model/Player/RandomPlayer.swift

@@ -6,8 +6,9 @@
 //
 
 import Foundation
-class RandomPlayer : AIPlayer {
+public class RandomPlayer : AIPlayer {
-    override func play() -> Move {
+    public override func play(board: Board) -> Move {
-        return Move(row: 0, column: 0)
+        let moves = rules.possibleMoves(board: board)
+        return moves.randomElement() ?? Move(row: 0, column: 0)
     }
 }

Model/Sources/Model/Rules.swift

@@ -8,8 +8,8 @@
 import Foundation
 
 public protocol Rules {
-    func add(board: inout Board, position pos: (row: Int, column: Int), token: Token) -> Bool
+    mutating func add(board: inout Board, move pos: Move, token: Token)
     func isGameOver(board: Board) -> (result: Bool, winner: Token)
     func possibleMoves(board: Board) -> [Move]
-    
+    func nextPlayer(players: [Player]) -> Player
 }

Model/Sources/Model/TicTacToeRules.swift

@@ -5,7 +5,7 @@
 //  Created by Adam BONAFOS on 14/01/2025.
 //
 
-import Foundation
+/*import Foundation
 public struct TicTacToeRules: Rules {
     
     public func possibleMoves(board: Board) -> [Move] {
@@ -36,4 +36,4 @@ public struct TicTacToeRules: Rules {
         return (false, Token.empty)
     }
 
-}
+}*/