Sujet Précédent Sujet Suivant

Jeu d'echecs python

smaug_99 - 6 févr. 2024 à 00:57
mamiemando Messages postés 33385 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 27 novembre 2024 - 6 févr. 2024 à 19:03

Bonjour, je suis en grosse galere et je n'arrive pas a finaliser min code de jeu d'echecs,je recherche de l'aide desperement qlqn peut m'aider svp : 

import pygame
from .Pieces import *
from .constant import *

class newBoard:
    def __init__(self, Width, Height, Rows, Cols, Square, win):
        self.Width = Width
        self.Height = Height
        self.Square = Square
        self.win = win
        self.Rows = Rows
        self.Cols = Cols
        self.Board = []
        self.create_Board()

    def create_Board(self):
        for row in range(self.Rows):
            self.Board.append([0 for i in range(self.Cols)])

            for col in range(self.Cols):
                if row == 1:
                    self.Board[row][col] = Pawn(self.Square, Black_Pawn, Black, "Pawn", row, col)

                if row == 6:
                    self.Board[row][col] = Pawn(self.Square, White_Pawn, Black, "Pawn", row, col)
                
                if row == 0:
                    if col == 0 or col == 7:
                        self.Board[row][col] = Rook(self.Square, Black_Rook, Black, "Rook", row, col)
                    
                    if col == 6 or col == 1:
                        self.Board[row][col] = Knight(self.Square, Black_Knight, Black, "Knight", row, col)

                    if col == 5 or col == 2:
                        self.Board[row][col] = Bishop(self.Square, Black_Bishop, Black, "Bishop", row, col)

                    if col == 3:
                        self.Board[row][col] = Queen(self.Square, Black_Queen, Black, "Queen", row, col)
                    
                    if col == 4:
                        self.Board[row][col] = King(self.Square, Black_King, Black, "King", row, col)
                if row == 7:

                    if col == 0 or col == 7:
                        self.Board[row][col] = Rook(self.Square, White_Rook, White, "Rook", row, col)
                    
                    if col == 6 or col == 1:
                        self.Board[row][col] = Knight(self.Square, White_Knight, White, "Knight", row, col)

                    if col == 5 or col == 2:
                        self.Board[row][col] = Bishop(self.Square, White_Bishop, White, "Bishop", row, col)

                    if col == 3:
                        self.Board[row][col] = Queen(self.Square, White_Queen, White, "Queen", row, col)
                    
                    if col == 4:
                        self.Board[row][col] = King(self.Square, White_King, White, "King", row, col)
            
    def get_piece(self, row, col):
        return self.Board[row][col]
    
    def moove(self, piece, row, col):
        self.Board[piece.row][piece.col], self.Board[row][col] = self.Board[row][col], self.Board[piece.row][piece.col]

        piece.piece_moove(row, col)

        if piece.type == "Pawn":
            if piece.first_moove:
                piece.first_moove = False

    def draw_Board(self, win):
        win.fill(Brown)

        for row in range(self.Rows):
            for col in range(self.Cols):
                color = White if (row + col) % 2 == 0 else Brown
                pygame.draw.rect(win, color, (col * self.Square, row * self.Square, self.Square, self.Square))

        for row in range(self.Rows):
            for col in range(self.Cols):
                if self.Board[row][col] != 0:
                    piece = self.Board[row][col]
                    x, y = col * self.Square, row * self.Square
                    piece.draw_piece(win, x, y)

    def draw_pieces(self):
        for row in range(self.Rows):
            for col in range(self.Cols):
                if self.Board[row][col] != 0:
                    piece = self.Board[row][col]
                    piece.draw_piece(self.win)

    
    


</code>

<code>import pygame
import os

Width, Height= 760, 760
Rows, Cols = 8, 8
Square = Width//Rows
path = "Chess_game\chess_image"

Brown = (87,16,16)
White = (255,255,255)
Green = (0,255,0)
Black = (0,0,0)

#piece_noir
Black_Knight = pygame.transform.scale(pygame.image.load(os.path.join(path, "cheval.png")),(Square, Square))
Black_King = pygame.transform.scale(pygame.image.load(os.path.join(path, "king.png")),(Square, Square))
Black_Bishop = pygame.transform.scale(pygame.image.load(os.path.join(path, "fou.png")),(Square, Square))
Black_Pawn = pygame.transform.scale(pygame.image.load(os.path.join(path, "petit_pion.png")),(Square, Square))
Black_Rook = pygame.transform.scale(pygame.image.load(os.path.join(path, "tour.png")),(Square, Square))
Black_Queen = pygame.transform.scale(pygame.image.load(os.path.join(path, "queen.png")),(Square, Square))

#piece blanche
White_Knight = pygame.transform.scale(pygame.image.load(os.path.join(path, "white_cheval.png")),(Square, Square))
White_King = pygame.transform.scale(pygame.image.load(os.path.join(path, "white_king.png")),(Square, Square))
White_Bishop = pygame.transform.scale(pygame.image.load(os.path.join(path, "white_fou.png")),(Square, Square))
White_Pawn = pygame.transform.scale(pygame.image.load(os.path.join(path, "white_pion.png")),(Square, Square))
White_Rook = pygame.transform.scale(pygame.image.load(os.path.join(path, "white_tour.png")),(Square, Square))
White_Queen = pygame.transform.scale(pygame.image.load(os.path.join(path, "white_queen.png")),(Square, Square))</code>

<code>import pygame
from .Board import *
from .constant import *
from copy import deepcopy

class Game:
    def __init__(self, Width, Height, Rows, Cols, Square, win):
        self.win = win
        self.Board = newBoard(Width, Height, Rows, Cols, Square, win)
        self.Square = Square
        self.selected = None
        self.turn = White
        self.valid_moves = []
        self.Black_pieces_left = 16
        self.White_pieces_left = 16

    def update_window(self):
        self.Board.draw_Board(self.win)
        self.Board.draw_pieces()
        self.draw_available_moves()
        pygame.display.update()

    def check_game(self):
        if self.checkmate(self.Board):
            if self.turn == White:
                print("Black Wins")
                return True
            else:
                print("White wins")
                return True

    def enemmies_moves(self, piece, Board):
        enemmies_moves = []
        for r in range(len(Board)):
            for c in range(len(Board[r])):
                if Board[r][c] != 0:
                    if Board[r][c].color != piece.color:
                        moves = Board[r][c].get_available_moves(r,c, Board)
                        for move in moves:
                            enemmies_moves.append(move)
        return enemmies_moves

    def get_King_pos(self, Board):
        for r in range(len(Board)):
            for c in range(len(Board)):
                if Board[r][c] != 0:
                    if Board[r][c].type == "King" and Board[r][c].color == self.turn:
                        return (r,c)

    def possible_moves(self, Board):
        possible_moves = []
        for r in range(len(Board)):
            for c in range(len(Board[r])):
                if Board[r][c] != 0:
                    if Board[r][c].color == self.turn and Board[r][c].type != "King":
                        moves = Board[r][c].get_available_moves(r,c, Board)

                        for move in moves:
                            possible_moves.append(move)
        return possible_moves

    def checkmate(self, Board):
        king_pos = self.get_King_pos(Board.Board)
        get_King = Board.get_piece(king_pos[0], king_pos[1])

        king_available_moves = set(get_King.get_available_moves(king_pos[0], king_pos[1], Board.Board))
        enemies_moves_set = set(self.enemmies_moves(get_King, Board.Board))
        king_moves = king_available_moves - enemies_moves_set
        set1 = king_available_moves.intersection(enemies_moves_set)
        possible_moves_to_def = set1.intersection(self.possible_moves(Board.Board))

        if not king_moves and king_available_moves and not possible_moves_to_def:
            return True
        
        return False

    def simulate_move(self, piece, row, col):
        piece_row, piece_col = piece.row, piece.col
        save_piece = self.Board.Board[row][col]

        if self.Board.Board[row][col] != 0:
            self.Board.Board[row][col] = 0
        
        self.Board.Board[piece.row][piece.col], self.Board.Board[row][col] = self.Board.Board[row][col], self.Board.Board[piece.row][piece.col] 

        king_pos = self.get_King_pos(self.Board.Board)
        if king_pos in self.enemies_moves(piece, self.Board):
            piece.row, piece.col = piece.row, piece_col
            self.Board[piece_row][piece_col] = piece
            self.Board.Board[row][col] = save_piece
            return False

        piece.row, piece.col = piece_row, piece_col
        self.Board.Board[piece_row][piece_col] = piece
        self.Board.Board[row][col] = save_piece
        return True

    def reset(self):
        self.Board = newBoard(Width, Height, Rows, Cols, Square, win)
        self.selected = None
        self.Black_pieces_left = 16
        self.White_pieces_left = 16
        self.valid_moves = []

    def change_turn(self):
        if self.turn == White:
            self.turn = Black
        else:
            self.turn = White
    
    def select(self, row,col):
        if self.selected:
            move = self._move(row, col)

            if not move:
                self.selected = None
                self.selected(row, col)
        piece = self.Board.get_piece(row, col)
        if piece != 0 and self.turn == piece.color:
            self.selected = piece

            self.valid_moves = piece.get_available_moves(row, col, self.Board.Board)


    def _move(self, row, col):
        piece = self.Board.get_piece(row, col)

        if self.selected and (row, col) in self.valid_moves:
            if piece == 0 or piece.color != self.selected.color:
                if self.simulate_move(self.selected, row, col):
                    self.remove(self.selected, row, col)

                    self.moove(piece, row, col)
                    self.change_turn()
                    self.valid_moves = []        
                    self.selected = None
                    return True
                return False
        return False
    
    def remove(self, Board, piece, row, col):
        if piece != 0:
            Board[row][col] = 0
            if piece.color == White:
                self.White_pieces_left -= 1
            else:
                self.Black_pieces_left -= 1

    def draw_available_moves(self):
        if len(self.valid_moves) > 0:
            for pos in self.valid_moves:
                row, col = pos[0], pos[1]
                pygame.draw.circle(self.win, Green, (col*self,Square + self.Square//2), self.Square//8)

        </code>

<code>import pygame
from .constant import *
from .Board import *

class Piece:
    def __init__(self, Square, image,color, type, row,col):
        self.Square = Square
        self.image = image
        self.color = color
        self.row = row 
        self.col = col
        self.type = type
        self.x = 0
        self.y = 0
        self.availables_moves = []
    
    def draw_piece(self, win):
        x = self.col * self.Square
        y = self.row * self.Square
        win.blit(self.image, (x, y))

    def piece_moove(self,row,col):
        self.row = row
        self.col = col
        self.calc_pos()

    def calc_pos(self):
        self.x = self.col*self.Square
        self.y = self.row*self.Square

    def clear_available_moves(self):
        if len(self.availables_moves) > 0:
            self.availables_moves = []

class Pawn(Piece):
    def __init__(self, Square, image, color, type, row, col):
        super().__init__(Square, image, color, type, row, col)
        self.first_moove = True
    
    def draw_piece(self, win):
        x = self.col * self.Square
        y = self.row * self.Square
        win.blit(self.image, (x, y))

    def get_available_moves(self, row, col, Board):
        self.clear_available_moves()

        if self.color == White:
            if row-1 >= 0:
                if Board[row-1][col] == 0:
                    self.availables_moves.append((row-1, col))

                if self.first_moove:

                    if Board[row-1][col] == 0:
                        self.availables_moves.append((row-2, col))

                if col-1 >= 0:
                    if Board[row+1][col-1] != 0:
                        piece = Board[row+2][col-1]
                        if piece.color != self.color:
                            self.availables_moves.append((row+1, col-1))

                if col+1 < len(Board):
                    if Board[row+1][col+1] != 0:
                        piece = Board[row+1][col+1]
                        if piece.color != self.color:
                            self.availables_moves.append((row+1,col+1))

        return self.availables_moves

class Rook(Piece):
    
    def __init__(self, Square, image, color, type, row, col):
        super().__init__(Square, image, color, type, row, col)

    def draw_piece(self, win):
        x = self.col * self.Square
        y = self.row * self.Square
        win.blit(self.image, (x, y))


    def get_available_moves(self, row, col, Board):
        self.clear_available_moves()
        for i in range(row+1,8):
            if Board[i][col] == 0:
                self.availables_moves.append((i,col))
            else:
                if Board[i][col].color != self.color:
                    self.availables_moves.append((i,col))
                    break
                else:
                    break

        for j in range(row-1,-1,-1):
            if Board[j][col] == 0:    
                self.availables_moves.append((j,col))

            else:
                if Board[j][col].color != self.color:
                    self.availables_moves.append((j,col))   
                    break
                else:
                    break

        for i in range(col+1,8):
            if Board[row][i] == 0:
                self.availables_moves.append((row,i))

            else:
                if Board[row][i].color:
                    self.availables_moves.append((row,i))        
                    break
                else:
                    break

        for i in range(col-1,-1,-1):
            if Board[row][i] == 0:
                self.availables_moves.append((row,i))

            else:
                if Board[row][i].color:
                    self.availables_moves.append((row,i))        
                    break
                else:
                    break

        return self.availables_moves

class Bishop(Piece):
    
    def __init__(self, Square, image, color, type, row, col):
        super().__init__(Square, image, color, type, row, col)

    def draw_piece(self, win):
        x = self.col * self.Square
        y = self.row * self.Square
        win.blit(self.image, (x, y))
    
    def get_available_moves(self, row, col, Board):
        self.clear_available_moves()

        row_i = row+1
        col_i = col+1

        while row_i <= 7 and col_i <= 7:
            if Board[row_i][col_i] == 0:
                self.availables_moves.append((row_i,col_i))
                row_i += 1
                col_i += 1
            
            else:
                if Board[row_i][col_i].color != self.color:
                    self.availables_moves.append((row_i,col_i))
                    break
                else:
                    break
        
        row_i = row-1
        col_i = col-1
        while row_i >= 0 and col_i >= 0:
            if Board[row_i][col_i] == 0:
                self.availables_moves.append((row_i,col_i))
                row_i -= 1
                col_i -= 1

            else:
                if Board[row_i][col_i].color != self.color:
                    self.availables_moves.append((row_i,col_i))
                    break
                else:
                    break
        
        row_i = row+1
        col_i = col-1
        while row_i <= 7 and col_i >=0:
            if Board[row_i][col_i] == 0:
                self.availables_moves.append((row_i,col_i))
                row_i += 1
                col_i -= 1

            else:
                if Board[row_i][col_i].color != self.color:
                    self.availables_moves.append((row_i,col_i))
                    break
                else:
                    break

        row_i = row-1
        col_i = col+1
        while row_i >= 0 and col_i <= 7:
            if Board[row_i][col_i] == 0:
                self.availables_moves.append((row_i,col_i))
                row_i -= 1
                col_i += 1

            else:
                if Board[row_i][col_i].color != self.color:
                    self.availables_moves.append((row_i,col_i))
                    break
                else:
                    break

        return self.availables_moves

class Knight(Piece):

    def __init__(self, Square, image, color, type, row, col):
        super().__init__(Square, image, color, type, row, col)

    def draw_piece(self, win):
        x = self.col * self.Square
        y = self.row * self.Square
        win.blit(self.image, (x, y))
    
    def get_available_moves(self, row, col, Board):
        self.clear_available_moves()

        if row-2 >= 0 and col+1 < len(Board):
            if Board[row-2][col+1] == 0 or Board[row-2][col+1].color != self.color:
                self.availables_moves.append((row-2, col+1))

        if row-1 >= 0 and col+2 < len(Board[0]):
            if Board[row-1][col+2] == 0 or Board[row-1][col+2].color != self.color:
                self.availables_moves.append((row-1, col+2))

        if row+1 < len(Board) and col+2 < len(Board):
            if Board[row+1][col+2] == 0 or Board[row+1][col+2].color != self.color:
                self.availables_moves.append((row+1, col+2))
        
        if row+2 < len(Board) and col+1 < len(Board):
            if Board[row+2][col+1] == 0 or Board[row+2][col+1].color != self.color:
                self.availables_moves.append((row+2, col+1))

        if row+2 < len(Board) and col-1 >= 0:
            if Board[row+2][col-1] == 0 or Board[row+2][col-1].color != self.color:
                self.availables_moves.append((row+2, col-1))

        if row+1 < len(Board) and col-2 >= 0:
            if Board[row+1][col-2] == 0 or Board[row+1][col-2].color != self.color:
                self.availables_moves.append((row+1, col-2))

        if row-1 >= 0 and col-2 >= 0:
            if Board[row-1][col-2] == 0 or Board[row-1][col-2].color != self.color:
                self.availables_moves.append((row-1, col-2))
        
        if row-2 >=0 and col-1 >= 0:
            if Board[row-2][col-1] == 0 or Board[row-2][col-1].color != self.color:
                self.availables_moves.append((row-2, col-1))

        return self.availables_moves


class Queen(Piece):

    def __init__(self, Square, image, color, type, row, col):
        super().__init__(Square, image, color, type, row, col)

    def draw_piece(self, win):
        x = self.col * self.Square
        y = self.row * self.Square
        win.blit(self.image, (x, y))
    
    def get_available_moves(self, row, col, Board):
        self.clear_available_moves()

        row_i = row+1
        col_i = col+1

        while row_i <= 7 and col_i <= 7:
            if Board[row_i][col_i] == 0:
                self.availables_moves.append((row_i,col_i))
                row_i += 1
                col_i += 1
            
            else:
                if Board[row_i][col_i].color != self.color:
                    self.availables_moves.append((row_i,col_i))
                    break
                else:
                    break
        
        row_i = row-1
        col_i = col-1
        while row_i >= 0 and col_i >= 0:
            if Board[row_i][col_i] == 0:
                self.availables_moves.append((row_i,col_i))
                row_i -= 1
                col_i -= 1

            else:
                if Board[row_i][col_i].color != self.color:
                    self.availables_moves.append((row_i,col_i))
                    break
                else:
                    break
        
        row_i = row+1
        col_i = col-1
        while row_i <= 7 and col_i >=0:
            if Board[row_i][col_i] == 0:
                self.availables_moves.append((row_i,col_i))
                row_i += 1
                col_i -= 1

            else:
                if Board[row_i][col_i].color != self.color:
                    self.availables_moves.append((row_i,col_i))
                    break
                else:
                    break

        row_i = row-1
        col_i = col+1

        while row_i >= 0 and col_i <= 7:
            if Board[row_i][col_i] == 0:
                self.availables_moves.append((row_i,col_i))
                row_i -= 1
                col_i += 1

            else:
                if Board[row_i][col_i].color != self.color:
                    self.availables_moves.append((row_i,col_i))
                    break
                else:
                    break
        for i in range(row+1,8):
            if Board[i][col] == 0:
                self.availables_moves.append((i,col))
            else:
                if Board[i][col].color != self.color:
                    self.availables_moves.append((i,col))
                    break
                else:
                    break

        for j in range(row-1,-1,-1):
            if Board[j][col] == 0:    
                self.availables_moves.append((j,col))

            else:
                if Board[j][col].color != self.color:
                    self.availables_moves.append((j,col))   
                    break
                else:
                    break

        for i in range(col+1,8):
            if Board[row][i] == 0:
                self.availables_moves.append((row,i))

            else:
                if Board[row][i].color:
                    self.availables_moves.append((row,i))        
                    break
                else:
                    break

        for i in range(col-1,-1,-1):
            if Board[row][i] == 0:
                self.availables_moves.append((row,i))

            else:
                if Board[row][i].color:
                    self.availables_moves.append((row,i))        
                    break
                else:
                    break

        return self.availables_moves

class King(Piece):

    def __init__(self, Square, image, color, type, row, col):
        super().__init__(Square, image, color, type, row, col)

    def draw_piece(self, win):
        x = self.col * self.Square
        y = self.row * self.Square
        win.blit(self.image, (x, y))
    
    def get_available_moves(self, row, col, Board):
        self.clear_available_moves()
        
        if row-1 >= 0:
            if Board[row-1][col] == 0 or Board[row-1][col].color != self.color:
                self.availables_moves.append((row-1,col))

        if row-1 >= 0 and col+1 < len(Board):
            if Board[row-1][col+1] == 0 or Board[row-1][col+1].color != self.color:
                self.availables_moves.append((row-1,col+1))

        if col+1 < len(Board):
            if Board[row][col+1] == 0 or Board[row][col+1].color != self.color:
                self.availables_moves.append((row,col+1))

        if row+1 <len(Board) and col+1 < len(Board):
            if Board[row+1][col+1] == 0 or Board[row+1][col+1].color != self.color:
                self.availables_moves.append((row+1,col+1))

        if row+1 < len(Board):
            if Board[row+1][col] == 0 or Board[row+1][col].color != self.color:
                self.availables_moves.append((row+1,col))
        
        if row+1 <len(Board) and col-1 >= 0:
            if Board[row+1][col-1] == 0 or Board[row+1][col-1].color != self.color:
                self.availables_moves.append((row+1,col-1))
            
        if col-1 >=0:
            if Board[row][col-1] == 0 or Board[row][col-1].color != self.color:
                self.availables_moves.append((row,col-1))
        
        if row-1 >= 0 and col-1 >= 0:
            if Board[row-1][col-1] == 0 or Board[row-1][col-1].color != self.color:
                self.availables_moves.append((row-1,col-1))
        
        return self.availables_moves

    </code>

<code>import pygame
from Chess_game.constant import *
from Chess_game.Game import Game
from Chess_game.Board import newBoard

pygame.init()

clock = pygame.time.Clock()

win = pygame.display.set_mode((Width, Height))

def get_position(x, y):
    row = y // Square
    col = x // Square
    return row, col

def main():
    run = True
    FPS = 60
    Cols = 8
    Rows = 8
    game = Game(Width, Height, Rows, Cols, Square, win)
    game_over = False
    
    while run:
        clock.tick(FPS)
        game.update_window()
        
        if game.check_game():
            game_over = True

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                run = False
                quit()

            if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE and game_over:
                game.reset()
                game_over = False  # Réinitialisez le drapeau game_over
                    
            if event.type == pygame.MOUSEBUTTONDOWN and not game_over:
                if pygame.mouse.get_pressed()[0]:
                    location = pygame.mouse.get_pos()
                    row, col = get_position(location[0], location[1])
                    game.select(row, col)
                    game._move(row, col)
main()


Windows / Chrome 121.0.0.0

A voir également:

3 réponses

Réponse 1 / 3
PierrotLeFou
6 févr. 2024 à 02:46

Il y a à peine 750 lignes dans ton code. Tu crois qu'on va s'y retrouver?

En plus, tu ne dis pas sur quoi tu galères.
1
smaug_99 Messages postés 3 Date d'inscription mardi 6 février 2024 Statut Membre Dernière intervention 6 février 2024
6 févr. 2024 à 18:58

desole je n'ai pas vraiment realiser, je n'en pouvais plus de voir ce projet presque fini et de ne pas pouvoir trouver une bete erreur qui n'est surment pas tres compliquer a modifier

0
Réponse 2 / 3
mamiemando Messages postés 33385 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 27 novembre 2024 7 803
6 févr. 2024 à 15:25

Bonjour,

Quand tu demandes de l'aide sur un forum, il faut mieux cibler un problème précis. Comme le dit Pierrot, on ne sait pas ce qui te bloque.

Avant de te lancer dans le code, il est sans doute souhaitable de faire un petit diagramme de classe pour identifier tous les objets dont tu auras besoin et comment ils interagissent entre eux. Ton enseignant t'a sans doute donné quelques bases en UML pour architecturer ton projet.

Ensuite quand tu développes un projet, il faut y aller petit à petit, et ajouter progressivement des éléments. Par exemple il n'est peut-être pas nécessaire de commencer directement avec Pygame, tu peux sans doute commencer par coder le moteur du jeu avec une interface en mode texte.

Ton diagramme de classe te permettra sans doute d'identifier les classes à développer en priorité. Par exemple, tu peux sans doute commencer par coder la notion de tour de jeu (à qui est-ce jouer), puis de plateau, et ensuite de pièces. Ensuite tu peux sans doute coder une pièce (disons le roi), vérifier qu'elle se comporte comme prévu, puis ajouter progressivement chaque type de pièce. En outre il est important de vérifier (hormis pour le cavalier, qu'une pièce n'en traverse pas une autre au cours de son mouvement, à moins bien sûr que ce soit la case qui termine le mouvement (prise). Dans ce cas, il faut vérifier que la pièce est bien dans le camp adverse.

Plus tard, tu pourras peaufiner (roque, prise en passant, interface graphique), mais si tu veux t'en sortir, il faut te focaliser sur le plus important et ne pas vouloir tout faire en même temps. Et à chaque fois que tu développes une fonctionnalité, tu la teste avant d'en ajouter une nouvelle. Ainsi, en cas de problème, l'erreur est a priori dans ce que tu viens de rajouter...

Bonne chance
1
smaug_99 Messages postés 3 Date d'inscription mardi 6 février 2024 Statut Membre Dernière intervention 6 février 2024
6 févr. 2024 à 18:57

merci beaucoup, mais tout cela a été beaucoup de travail, je trouve ca dommage de tout recommencer une troisieme fois pour ma part mais ca va je vais me debrouiller merci beaucoup

0
mamiemando Messages postés 33385 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 27 novembre 2024 7 803 > smaug_99 Messages postés 3 Date d'inscription mardi 6 février 2024 Statut Membre Dernière intervention 6 février 2024
6 févr. 2024 à 19:03

Tu n'es pas obligé de recommencer, tu peux repartir d'où tu en es. Mais vu tes questions tu ne sembles plus savoir où tu en es. Donc là il faut commencer par alterner les tours de jeu entre les joueurs et les inviter à déplacer une pièce, puis contrôler que ce mouvement est valide... Si c'est le cas, on passe à l'autre joueur.

0
Réponse 3 / 3
smaug_99 Messages postés 3 Date d'inscription mardi 6 février 2024 Statut Membre Dernière intervention 6 février 2024
6 févr. 2024 à 00:59

je vous ai envoyé tout d'un coup mais evidement tout est separer dans plusieurs dossier
0

Discussions similaires

Google Chrome "  Échec de l'analyse antivirus "
jmpower -
RBmoon -

18 réponses
Jeu avec réponses à donner
sylmarco -
bmohr -

4 réponses