Update(Tp3): Fix name method but still broken

Model/Sources/Model/Interface/Rules.swift

@@ -13,20 +13,20 @@ protocol Rules {
     // pas forcément utile si j'utilise pas playedMove
     var historic: [Move] { get set }
 
-    func static createBoard() -> Board
+    static func createBoard() -> Board
-    func static checkBoard( b: Board) throws
+    static func checkBoard( b: Board) throws
     func getNextPlayer() -> Owner
 
     // Donne tout les coups autoriser
-    func getMoves( board: Board,  owner: Owner) -> [Move]
+    func getMoves( board: Board, owner: Owner) -> [Move]
     
     // Donne tout les coups autoriser à partir d'une cellule 
-    func getMoves( board: Board,  owner: Owner,  row: Int,  column: Int) -> [Move]
+    func getMoves( board: Board, owner: Owner, row: Int, column: Int) -> [Move]
     
-    func isMoveValid( board: Board,  row: Int, column: Int, rowArrived: Int, columnArrived: Int) -> Bool
+    func isMoveValid( board: Board, row: Int, column: Int, rowArrived: Int, columnArrived: Int) -> Bool
-    func isMoveValid( board: Board,  move: Move) -> Bool
+    func isMoveValid( board: Board, move: Move) -> Bool
-    func isGameOver( board: Board,  lastMove: Move) -> (Bool, Result)
+    func isGameOver( board: Board, lastMove: Move) -> (Bool, Result)
     
     // permet de stocker le coût qui a été fait. (playedMove)
-    func playedMove( move: Move,  oldBoard: Board,  newBoard: Board)
+    func playedMove(move: Move, oldBoard: Board, newBoard: Board)
 }

Model/Sources/Model/VerySimpleRules.swift

@@ -11,7 +11,7 @@ struct VerySimpleRules: Rules {
     var occurences = [Board: Int]()
     var historic = [Move]()
     
-    func createBoard() -> Board {
+    static func createBoard() -> Board {
         var cells = [[Cell]]()
 
         // Configuration initiale du plateau
@@ -28,7 +28,7 @@ struct VerySimpleRules: Rules {
 
                 if owner != .noOne && column < initialSetup.count {
                     if let animal = initialSetup[column] {
-                        piece = Piece(owner: owner, animal: animal)
+                        piece = Piece(withOwner: owner, andAnimal: animal)
                     }
                 }
 
@@ -37,10 +37,15 @@ struct VerySimpleRules: Rules {
             cells.append(rowCells)
         }
 
-        return Board(grid: cells)
+        return Board(withGrid: cells)
     }
     
-    func checkBoard(_ b: Board) throws {
+    func getNextPlayer() -> Owner {
+        // Implémentation basée sur l'historique des coups
+        return historic.last?.owner == .player1 ? .player2 : .player1
+    }
+    
+    static func checkBoard(b: Board) throws {
         // Vérifier les dimensions du plateau
         guard b.nbRows == 5, b.nbColumns == 5 else {
             throw InvalidBoardError.badDimensions(b.nbRows, b.nbColumns)
@@ -70,18 +75,13 @@ struct VerySimpleRules: Rules {
         }
     }
     
-    func getNextPlayer() -> Owner {
+    func getMoves(board: Board, owner: Owner) -> [Move] {
-        // Implémentation basée sur l'historique des coups
-        return historic.last?.owner == .player1 ? .player2 : .player1
-    }
-
-    func getMoves(_ board: Board, _ owner: Owner) -> [Move] {
         var moves = [Move]()
 
         for row in 0..<board.nbRows {
             for col in 0..<board.nbColumns {
                 if let cell = board.grid[row][col], cell.piece?.owner == owner {
-                    moves.append(contentsOf: getMoves(board, owner, row, col))
+                    moves.append(contentsOf: getMoves(board: board, owner: owner, row: row, column: col))
                 }
             }
         }
@@ -89,72 +89,79 @@ struct VerySimpleRules: Rules {
         return moves
     }
     
+    func getMoves(board: Board, owner: Owner, row: Int, column: Int) -> [Move] {
+        var moves = [Move]()
         
-    func getMoves(_ board: Board, _ owner: Owner, _ row: Int, _ column: Int) -> [Move] {
+        // Directions: haut, bas, gauche, droite
-            var moves = [Move]()
+        let directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
-            
-            // Directions: haut, bas, gauche, droite
-            let directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
 
-            for (dRow, dCol) in directions {
+        for (dRow, dCol) in directions {
-                let newRow = row + dRow
+            let newRow = row + dRow
-                let newCol = column + dCol
+            let newCol = column + dCol
 
-                if newRow >= 0, newRow < board.nbRows, newCol >= 0, newCol < board.nbColumns,
+            if newRow >= 0, newRow < board.nbRows, newCol >= 0, newCol < board.nbColumns,
-                   let destinationCell = board.grid[newRow][newCol],
+               let destinationCell = board.grid[newRow][newCol],
-                   destinationCell.piece?.owner != owner {
+               destinationCell.piece?.owner != owner {
-                    moves.append(Move(owner: owner, rowOrigin: row, columnOrigin: column, rowDestination: newRow, columnDestination: newCol))
+                moves.append(Move(owner: owner, rowOrigin: row, columnOrigin: column, rowDestination: newRow, columnDestination: newCol))
-                }
             }
-
-            return moves
         }
 
-        func isMoveValid(_ board: Board, _ move: Move) -> Bool {
+        return moves
-            // Vérifier si les coordonnées de destination sont valides
+    }
-            if move.rowDestination < 0 || move.rowDestination >= board.nbRows ||
-               move.columnDestination < 0 || move.columnDestination >= board.nbColumns {
-                return false
-            }
-
-            // Vérifier si la case de destination est occupée par une pièce du même joueur
-            if let destinationCell = board.grid[move.rowDestination][move.columnDestination],
-               let piece = destinationCell.piece,
-               piece.owner == move.owner {
-                return false
-            }
     
-            // Autres vérifications spécifiques au jeu peuvent être ajoutées ici
+    func isMoveValid(board: Board, move: Move) -> Bool {
-            // ...
+        // Vérifier si les coordonnées de destination sont valides
+        if move.rowDestination < 0 || move.rowDestination >= board.nbRows ||
+           move.columnDestination < 0 || move.columnDestination >= board.nbColumns {
+            return false
+        }
 
-            return true
+        // Vérifier si la case de destination est occupée par une pièce du même joueur
+        if let destinationCell = board.grid[move.rowDestination][move.columnDestination],
+           let piece = destinationCell.piece,
+           piece.owner == move.owner {
+            return false
         }
 
-        func isGameOver(_ board: Board, _ lastMove: Move) -> (Bool, Result) {
+        // Autres vérifications spécifiques au jeu peuvent être ajoutées ici
-            // Vérifier si la tannière de l'adversaire a été atteinte
+        // ...
-            let opponent = lastMove.owner == .player1 ? .player2 : .player1
-            if let destinationCell = board.grid[lastMove.rowDestination][lastMove.columnDestination],
-               destinationCell.cellType == .den, destinationCell.initialOwner == opponent {
-                return (true, .winner(lastMove.owner, .denReached))
-            }
 
-            // Vérifier si l'adversaire n'a plus de pièces
+        return true
-            let hasOpponentPieces = board.grid.flatMap { $0 }.contains { cell in
+    }
-                guard let piece = cell.piece else { return false }
-                return piece.owner == opponent
-            }
-            if !hasOpponentPieces {
-                return (true, .winner(lastMove.owner, .noMorePieces))
-            }
     
-            // Vérifier si l'adversaire ne peut plus bouger
+    func isMoveValid(board: Board, row: Int, column: Int, rowArrived: Int, columnArrived: Int) -> Bool {
-            let opponentMoves = getMoves(board, opponent)
+        <#code#>
-            if opponentMoves.isEmpty {
+    }
-                return (true, .winner(lastMove.owner, .noMovesLeft))
-            }
     
-            // Si aucune condition de victoire n'est remplie, la partie n'est pas encore terminée
+    func isGameOver(board: Board, lastMove: Move) -> (Bool, Result) {
-            return (false, .notFinished)
+        // Vérifier si la tannière de l'adversaire a été atteinte
+        let opponent = lastMove.owner == .player1 ? .player2 : .player1
+        if let destinationCell = board.grid[lastMove.rowDestination][lastMove.columnDestination],
+           destinationCell.cellType == .den, destinationCell.initialOwner == opponent {
+            return (true, .winner(lastMove.owner, .denReached))
         }
 
+        // Vérifier si l'adversaire n'a plus de pièces
+        let hasOpponentPieces = board.grid.flatMap { $0 }.contains { cell in
+            guard let piece = cell.piece else { return false }
+            return piece.owner == opponent
+        }
+        if !hasOpponentPieces {
+            return (true, .winner(lastMove.owner, .noMorePieces))
+        }
+
+        // Vérifier si l'adversaire ne peut plus bouger
+    let opponentMoves = getMoves(board: board, owner: opponent)
+        if opponentMoves.isEmpty {
+            return (true, .winner(lastMove.owner, .noMovesLeft))
+        }
+
+        // Si aucune condition de victoire n'est remplie, la partie n'est pas encore terminée
+        return (false, .notFinished)
+    }
+    
+    func playedMove(move: Move, oldBoard: Board, newBoard: Board) {
+        <#code#>
     }
+    
+}