Update(Tp5): refacto et fix bug mouvement

Model/Sources/Model/Game.swift

@@ -42,7 +42,7 @@ public struct Game {
             }
             
             do {
-                try rules.apply(move: move, to: &board) // Applique le mouvement
+                try rules.playedMove(move: move, to: &board) // Applique le mouvement
                 onMoveChosen?(move)
                 onBoardChanged?() // Notifie que le plateau a changé
                 

Model/Sources/Model/HumanPlayer.swift

@@ -18,7 +18,7 @@ public class HumanPlayer: Player {
     public override func chooseMove(board: Board, rules: Rules) -> Move? {
         print("Votre tour, \(name). Saisissez votre mouvement (format attendu : 'rowOrigin columnOrigin rowDestination columnDestination') :")
 
-        if let input = readLine() { // Déballez en toute sécurité l'entrée de l'utilisateur
+        if let input = readLine() { 
             let components = input.compactMap { Int(String($0)) }
             if components.count == 4,
                rules.isMoveValid(board: board, row: components[0], column: components[1], rowArrived: components[2], columnArrived: components[3]) {

Model/Sources/Model/Interface/Rules.swift

@@ -26,10 +26,8 @@ public protocol Rules {
     func isMoveValid( board: Board, row: Int, column: Int, rowArrived: Int, columnArrived: Int) -> Bool
     func isMoveValid( board: Board, move: Move) -> Bool
 
-    mutating func apply(move: Move, to board: inout Board) throws
-    
     func isGameOver( board: Board, lastMove: Move) -> (Bool, Result)
     
     // permet de stocker le coût qui a été fait. (playedMove)
-    mutating func playedMove(move: Move, oldBoard: Board, newBoard: Board)
+    mutating func playedMove(move: Move, to board: inout Board) throws
 }

Model/Sources/Model/VerySimpleRules.swift

@@ -116,28 +116,34 @@ public struct VerySimpleRules: Rules {
     }
         
     public func isMoveValid(board: Board, move: Move) -> Bool {
-        // Vérifier si les coordonnées de destination sont dans les limites du plateau
+        // 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 {
+            move.columnDestination < 0 || move.columnDestination >= board.nbColumns {
             return false
         }
         
         // Obtenir la cellule de destination
-        guard let destinationCell = board.getCell(atRow: move.rowDestination, column: move.columnDestination) else {
-            return false // Ne devrait pas se produire si les limites sont correctement vérifiées
-        }
-
-        // Vérifier si la destination est occupée par une pièce alliée
-        if let piece = destinationCell.piece, piece.owner == move.owner {
-            return false
+        let destinationCell = board.grid[move.rowDestination][move.columnDestination]
+        
+        // Si la case de destination est une case jungle, vérifier les conditions spécifiques
+        if destinationCell.cellType == .jungle {
+            // Vérifier si la case de destination est occupée par une pièce du même joueur
+            // Modifier cette logique si vous voulez permettre le déplacement sur des cases jungle occupées par des pièces alliées
+            if let piece = destinationCell.piece, piece.owner == move.owner {
+                return false // Retourner true si le déplacement est autorisé malgré la présence d'une pièce alliée
+            }
+        } else {
+            // Pour les autres types de cases, vérifier si la case de destination est occupée par une pièce du même joueur
+            if let piece = destinationCell.piece, piece.owner == move.owner {
+                return false
+            }
         }
         
-        // Ajouter ici d'autres vérifications spécifiques au jeu, comme les obstacles ou les règles spéciales de pièces
+        // Autres vérifications spécifiques à votre jeu (par exemple, les règles de déplacement basées sur le type de pièce)
         
-        return true // Le mouvement est valide si toutes les vérifications sont passées
+        return true // Le mouvement est valide si aucune des conditions d'invalidité n'est remplie
     }
     
-    
     public func isMoveValid(board: Board, row: Int, column: Int, rowArrived: Int, columnArrived: Int) -> Bool {
         // Création d'un objet Move à partir des coordonnées fournies
         let move = Move(owner: board.getCell(atRow: row, column: column)?.piece?.owner ?? .noOne,
@@ -151,30 +157,32 @@ public struct VerySimpleRules: Rules {
     }
 
     
-    public mutating func apply(move: Move, to board: inout Board) throws {
-        // Vérifier si le mouvement est valide
+    public mutating func playedMove(move: Move, to board: inout Board) throws {
+        // Assurez-vous que le mouvement est valide avant de continuer
         guard isMoveValid(board: board, move: move) else {
             throw GameError.invalidMove
         }
 
-        // Suppression de la pièce à l'origine
-        let removalResult = board.removePiece(atRow: move.rowOrigin, andColumn: move.columnOrigin)
-        guard removalResult == .ok else {
-            throw GameError.invalidMove // Ou une erreur plus spécifique si vous en avez défini
-        }
-
-        // Récupération de la pièce pour la déplacer
+        // Obtenez la pièce à déplacer
         guard let piece = board.getCell(atRow: move.rowOrigin, column: move.columnOrigin)?.piece else {
-            throw GameError.invalidMove // La pièce n'existe pas à l'origine prévue
+            throw GameError.invalidMove // Ou une erreur plus spécifique
         }
         
-        // Insertion de la pièce à la destination
+        // Supprimez la pièce de sa position d'origine
+        _ = board.removePiece(atRow: move.rowOrigin, andColumn: move.columnOrigin)
+
+        // Placez la pièce à sa nouvelle position
         let insertionResult = board.insert(piece: piece, atRow: move.rowDestination, andColumn: move.columnDestination)
-        guard insertionResult == .ok else {
-            throw GameError.invalidMove // Ou une erreur plus spécifique basée sur `insertionResult`
+        switch insertionResult {
+        case .ok:
+            print("Mouvement appliqué avec succès.")
+        case .failed(let reason):
+            print("Échec de l'application du mouvement : \(reason).")
+            // Vous pouvez convertir ceci en une erreur spécifique si nécessaire
+            throw GameError.invalidMove
         }
 
-        // Mettre à jour l'historique des mouvements
+        // Mettre à jour l'historique des mouvements ou d'autres états au besoin
         historic.append(move)
     }
 
@@ -210,10 +218,5 @@ public struct VerySimpleRules: Rules {
         // Si aucune condition de victoire n'est remplie, la partie n'est pas encore terminée
         return (false, .notFinished)
     }
-    
-    public mutating func playedMove(move: Move, oldBoard: Board, newBoard: Board) {
-        // Ajouter le mouvement à l'historique
-        historic.append(move)
-    }
 }