louis.dufour
/
LouisDuf-DouShouQi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update(Tp5): le jeu fonctionne avec 2 player

Browse Source
pull/6/head
Louis DUFOUR 1 year ago
parent 32ec77efbd
commit 524fb61e7c
3 changed files with 72 additions and 64 deletions
Show Stats Download Patch File Download Diff File

17
DouShouQiConsole/DouShouQiConsole/main.swift
Unescape View File

@ -96,19 +96,24 @@ func olMain(){
}
func main() {
guard let randomPlayer = RandomPlayer(withName: "Random Player 1", andId: .player1),
/*guard let randomPlayer = RandomPlayer(withName: "Random Player 1", andId: .player1),
let humanPlayer = HumanPlayer(name: "Human Player 2", id: .player2, inputMethod: { validMoves in
// Implémentez la logique pour choisir un mouvement valide ici.
// Ceci est juste un exemple, vous devez adapter cette partie.
return validMoves.first
}) else {
fatalError("Failed to initialize players")
}
}*/
guard let Humanplayer1 = HumanPlayer(name: "Player 1", id: .player1, inputMethod: { _ in nil }),
let Humanplayer2 = HumanPlayer(name: "Player 2", id: .player2, inputMethod: { _ in nil }) else {
fatalError("Failed to initialize players")
}
var game = Game(
rules: VerySimpleRules(),
player1: randomPlayer,
player2: humanPlayer
// player1: humanPlayer,
// player2: humanPlayer
player1: Humanplayer1,
player2: Humanplayer2
)
// Configuration des callbacks pour la gestion des événements de jeu

2
Model/Sources/Model/Board.swift
Unescape View File

@ -22,7 +22,7 @@ public struct Board : Hashable, Equatable {
self.grid=grid
}
public func getCell(atRow row: Int, column: Int) -> Cell? {
public func getCell(atRow row: Int, atColumn column: Int) -> Cell? {
guard row >= 0, row < nbRows, column >= 0, column < nbColumns else {
return nil
}

117
Model/Sources/Model/VerySimpleRules.swift
Unescape View File

@ -88,72 +88,60 @@ public struct VerySimpleRules: Rules {
public func getMoves(board: Board, owner: Owner) -> [Move] {
var moves = [Move]()
for row in 0..<board.nbRows {
for col in 0..<board.nbColumns {
let cell = board.grid[row][col]
if cell.piece?.owner == owner {
moves.append(contentsOf: getMoves(board: board, owner: owner, row: row, column: col))
for row in 0..<board.grid.count {
for column in 0..<board.grid[row].count {
if let piece = board.grid[row][column].piece, piece.owner == owner {
moves.append(contentsOf: getMoves(board: board, owner: owner, row: row, column: column))
}
}
}
return moves
}
public func getMoves(board: Board, owner: Owner, row: Int, column: Int) -> [Move] {
var moves = [Move]()
// Directions: haut, bas, gauche, droite
let directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
let directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] // Haut, Bas, Gauche, Droite
for (dRow, dCol) in directions {
let newRow = row + dRow
let newCol = column + dCol
if newRow >= 0, newRow < board.nbRows, newCol >= 0, newCol < board.nbColumns {
if newRow >= 0, newRow < board.grid.count, newCol >= 0, newCol < board.grid[0].count {
let destinationCell = board.grid[newRow][newCol]
if destinationCell.piece?.owner != owner {
// Autoriser le mouvement si la case de destination est vide ou contient une pièce ennemie
if destinationCell.piece == nil || destinationCell.piece?.owner != owner {
moves.append(Move(owner: owner, rowOrigin: row, columnOrigin: column, rowDestination: newRow, columnDestination: newCol))
}
}
return moves
}
return moves
}
public 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 {
// Assurez-vous que le mouvement est d'une case dans toutes les directions
let deltaRow = abs(move.rowDestination - move.rowOrigin)
let deltaColumn = abs(move.columnDestination - move.columnOrigin)
if deltaRow > 1 || deltaColumn > 1 || (deltaRow == 0 && deltaColumn == 0) {
return false
}
// Obtenir la cellule de destination
// Obtenez la cellule de destination
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
if let piece = destinationCell.piece, piece.owner == move.owner {
return false
}
} 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
}
// Vérifiez si la case de destination est occupée par une pièce alliée
if let piece = destinationCell.piece, piece.owner == move.owner {
return false
}
// 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
// Autres vérifications spécifiques à votre jeu...
return true
}
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,
let move = Move(owner: board.getCell(atRow: row, atColumn: column)?.piece?.owner ?? .noOne,
rowOrigin: row,
columnOrigin: column,
rowDestination: rowArrived,
@ -171,21 +159,28 @@ public struct VerySimpleRules: Rules {
}
// Obtenez la pièce à déplacer
guard let piece = board.getCell(atRow: move.rowOrigin, column: move.columnOrigin)?.piece else {
guard let movingPiece = board.getCell(atRow: move.rowOrigin, atColumn: move.columnOrigin)?.piece else {
throw GameError.invalidMove // Ou une erreur plus spécifique
}
// Vérifiez s'il y a une pièce ennemie à la position de destination et la supprimez si c'est le cas
if let destinationCell = board.getCell(atRow: move.rowDestination, atColumn: move.columnDestination), let destinationPiece = destinationCell.piece {
if destinationPiece.owner != movingPiece.owner {
// La pièce ennemie est capturée et doit être supprimée
_ = board.removePiece(atRow: move.rowDestination, andColumn: move.columnDestination)
}
}
// 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)
let insertionResult = board.insert(piece: movingPiece, atRow: move.rowDestination, andColumn: move.columnDestination)
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
}
@ -193,36 +188,44 @@ public struct VerySimpleRules: Rules {
historic.append(move)
}
public func hasPlayerNoPieces(board: Board, player: Owner) -> Bool {
for row in board.grid {
for cell in row {
if let piece = cell.piece, piece.owner == player {
return false
}
}
}
return true
}
public func isGameOver(board: Board, lastMove: Move) -> (Bool, Result) {
// Vérifier si la tannière de l'adversaire a été atteinte
var opponent: Owner
let destinationCell = board.grid[lastMove.rowDestination][lastMove.columnDestination]
var opponent:Owner
if lastMove.owner == .player1 {
opponent = .player2
} else {
opponent = .player1
}
let destinationCell = board.grid[lastMove.rowDestination][lastMove.columnDestination]
if destinationCell.cellType == .den, destinationCell.initialOwner == opponent {
// Vérifiez si la destination est la tanière de l'opposant
if 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érifie si la tanière de l'adversaire a été atteinte
if destinationCell.cellType == .den && destinationCell.initialOwner != lastMove.owner {
return (true, .winner(lastMove.owner, .denReached))
}
// 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))
// Vérifie si l'un des joueurs n'a plus de pièces
if hasPlayerNoPieces(board: board, player: opponent) {
return (true, .winner(lastMove.owner, .noMorePieces))
} else if hasPlayerNoPieces(board: board, player: lastMove.owner) {
return (true, .winner(opponent, .noMorePieces))
}
// Si aucune condition de victoire n'est remplie, la partie n'est pas encore terminée
return (false, .notFinished)
}
}

Write Preview
Loading…
Cancel
Save