def main():
run = True
clock = pygame.time.Clock()
board = Board()
board.create_board()
while (run):
clock.tick(FPS)
for e in pygame.event.get():
if (e.type == pygame.QUIT):
run = False
if (e.type == pygame.MOUSEBUTTONDOWN):
pos = pygame.mouse.get_pos()
col, row = get_row_col_from_mouse(pos)
piece = board.get_piece(row, col)
if piece:
if piece.is_hint and board.current_piece_coords[0] != None:
board.move(board.current_piece_coords[0],
board.current_piece_coords[1], row, col)
else:
if board.is_hint_shown:
board.remove_hints()
else:
board.mark_neighbours(piece)
board.draw_cubes(WIN)
board.draw_pieces(WIN)
pygame.display.update()
pass
pygame.quit()
def main():
run = True
clock = pygame.time.Clock()
board = Board() #New Object
#piece = board.get_piece(0,1)
while run:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
row, col = get_row_col_from_mouse(pos)
piece = board.get_piece(row, col)
board.move(piece, 4, 3)
board.draw(WIN)
pygame.display.update()
pygame.quit()
class Game(object):
"""Playing a game"""
BEGIN = 0
END = 1
PROGRESS = 2
def __init__(self, black_player, white_player):
self._width = 3
self._board = Board(self._width)
self._black_player = black_player
self._white_player = white_player
self._current_player = self._black_player
self._moves = []
self._steps = 0
self._state = Game.BEGIN
self._winner = None
@property
def moves(self):
return self._moves
@property
def steps(self):
return self._steps
def play(self):
while self._state != Game.END:
i, j = self._current_player.next_move(self._board)
if self._current_player == self._black_player:
self._board.move(i, j, Board.BLACK)
self._current_player = self._white_player
self._moves.append((i, j, Board.BLACK))
else:
self._board.move(i, j, Board.WHITE)
self._current_player = self._black_player
self._moves.append((i, j, Board.WHITE))
if self._state == Game.BEGIN:
self._state = Game.PROGRESS
self._steps += 1
if self._board.check_state() == Board.WHITE:
self._winner = self._white_player
self._state = Game.END
if self._board.check_state() == Board.BLACK:
self._winner = self._black_player
self._state = Game.END
@property
def winner(self):
if self._winner == self._white_player:
return 'WHITE'
elif self._winner == self._black_player:
return 'BLACK'
else:
return 'Nobody'
class Game:
def __init__(self, win):
self._init()
self.win = win
self.removed_counter = 0
self.valid_moves = {}
def winner(self):
return self.board.winner()
def _is_stuck(self, matchWinner):
return matchWinner
def update_board(self, row, col):
self.board.draw1(self.win, row, col)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
def update3(self, row3, col3):
self.board.draw3(self.win, row3, col3)
self.board.draw_selected(self.win, row3, col3)
pygame.display.update()
def _init(self):
self.selected = None
self.board = Board()
self.turn = RED
self.valid_moves = {} #a dictionary of current vallid moves
def reset(self):
self._init()
def select(self, row, col):
"""
get here when the player press on piece
if selected is vallid move piece if not (=not result) try again
"""
if self.selected:
rectOne = (100, 100, 100, 100)
pygame.draw.circle(self.win, BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 8)
pygame.draw.circle(self.win, GRAY,
(col * SQUARE_SIZE, row * SQUARE_SIZE), 14)
result = self.move(row, col) #try to move
if not result:
self.selected = None #delete invalid selected
self.select(row, col) #reselect
piece = self.board.get_piece(row, col)
self.board.draw_selected(self.win, row, col)
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
if not self.valid_moves:
self._is_stuck("WHITE")
return True
return False
def move(self, row, col):
piece = self.board.get_piece(row, col)
pygame.draw.circle(self.win, YELLOW,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 8)
#if the player selected an empty square and it's valid move
if self.selected and piece == 0 and (row, col) in self.valid_moves:
pygame.draw.circle(self.win, BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 8)
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
if skipped:
self.removed_counter = 0
self.board.remove(skipped)
else:
self.removed_counter = self.removed_counter + 1
self.change_turn()
else:
return False
return True
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 8)
def change_turn(self):
self.valid_moves = {}
if self.turn == RED:
self.turn = WHITE
else:
self.turn = RED
def get_board(self):
return self.board
def ai_move(
self, board
): #Since Game is a Controller class, it connects between the Board class (The View)
# and the Model- the Minimax Algorithm Class.
self.board = board
self.change_turn()
def test_board():
"""test init"""
board = Board(3)
zero_field = np.zeros((3, 3), dtype='int8')
game_field = board.field
assert board
assert (zero_field == game_field).all()
assert board.check_state() is None
"""test function move"""
board.move(0, 0, Board.BLACK)
board.move(0, 1, Board.WHITE)
game_field = board.field
assert game_field[0, 0] == Board.BLACK
assert game_field[0, 1] == Board.WHITE
try:
board.move(0, 1, Board.WHITE)
except AssertionError:
pass
try:
board.move(2, 2, 0)
except AssertionError:
pass
"""test function check_win"""
board.remove_all()
board.move(2, 0, Board.BLACK)
board.move(0, 2, Board.WHITE)
board.move(1, 2, Board.BLACK)
board.move(2, 1, Board.WHITE)
board.move(0, 0, Board.BLACK)
board.move(1, 1, Board.WHITE)
assert board.check_state() != Board.WHITE
"""test function remove"""
board.remove(0, 2)
board.remove(1, 1)
board.remove(2, 0)
game_field = board.field
assert game_field[0, 2] == 0
assert game_field[1, 1] == 0
assert game_field[2, 0] == 0
"""test function remove_all"""
board.remove_all()
game_field = board.field
assert (zero_field == game_field).all()
"""test function legal_moves"""
board.move(0, 0, Board.BLACK)
board.move(0, 1, Board.WHITE)
board.move(0, 2, Board.BLACK)
board.move(1, 0, Board.BLACK)
board.move(1, 1, Board.WHITE)
board.move(1, 2, Board.BLACK)
moves = set([(2, 0), (2, 1), (2, 2)])
assert board.legal_moves() == moves
class Game:
def __init__(self, win):
self._init()
self.win = win
# Update pygame display using this method
def update(self):
self.board.draw(self.win)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
# Initilizing => private method init
def _init(self):
self.selected = None
self.board = Board()
self.turn = RED
# dictionary of valid possible moves that can be taken from a position
self.valid_moves = {}
# Reset the game
def reset(self):
self._init()
# When select something => call the select method, tell the row and col selected and do something based on that
def select(self, row, col):
# Move the already selected piece to the desired row,col
if self.selected:
result = self._move(row, col)
# If incorrect/invalid move => reset the selection and reselect row and col
if not result:
self.selected = None
self.select(row, col)
piece = self.board.get_piece(row, col)
# not selecting an empty piece and the color of the piece is same as the turn
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
return True
return False
# Move currently selected piece to the row and col
def _move(self, row, col):
piece = self.board.get_piece(row, col)
# If we have selected something and the piece that we selected is empty and the row, col is a valid move then we can move it
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
if skipped:
self.board.remove(skipped)
self.change_turn()
else:
return False
return True
# Change the turn after the move
def change_turn(self):
self.valid_moves = []
if self.turn == RED:
self.turn = WHITE
else:
self.turn = RED
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 15)
def winner(self):
return self.board.winner()
class Game:
def __init__(self, win):
self._init()
self.win = win
def update(self):
self.board.draw(self.win)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
def _init(self):
self.selected = None
self.board = Board()
self.turn = RED
self.valid_moves = {}
def winner(self):
if self.board.winner() == WHITE:
winner = 'White'
elif self.board.winner() == RED:
winner = 'Red'
else:
winner = None
return winner
def reset(self):
self._init()
def select(self, row, col):
if self.selected:
result = self._move(row, col)
if not result:
self.selected = None
self.select(row, col)
piece = self.board.get_piece(row, col)
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
return True
return False
def _move(self, row, col):
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (
row, col
) in self.valid_moves: #s-a selectat un patrat care nu e gol
# si linia si coloana la care se va feca mutarea e valida
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)] #piesa peste care s-a sarit
if skipped:
self.board.remove(
skipped) #se elimina piesa peste care s-a sarit
self.change_turn()
else:
return False
return True
def draw_valid_moves(self, moves):
'''
Marcheaza toate mutarile pe care piesa selectata le poate face
:param moves: mutarile valide
:return:
'''
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 15)
def change_turn(self):
self.valid_moves = {}
if self.turn == RED:
self.turn = WHITE
else:
self.turn = RED
# -*- coding: UTF-8 -*-
from checkers.player import HumanPlayer, RandomPlayer
from checkers.board import Board
game_board = Board(3)
game_board.move(0, 0, Board.BLACK)
game_board.move(0, 1, Board.WHITE)
name = 'James'
a_player = HumanPlayer(name)
r_player = RandomPlayer('Random')
def test_human_player():
assert a_player.name == 'James'
assert r_player.name == 'Random'
# i, j = a_player.next_move(game_board)
# """input 1, 2"""
# assert (i, j) == (1, 2)
class Game:
def __init__(self, win):
self._init()
self.win = win
def update(self):
self.board.draw(self.win, self.turn)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
def _init(self):
self.selected = None
self.board = Board()
self.turn = WHITE
self.valid_moves = {}
def reset(self):
self._init()
def select(self, pos):
x, y = pos
row = y // SQUARE_SIZE
col = x // SQUARE_SIZE
if self.selected:
result = self._move(row, col)
if not result:
self.selected = None
self.select(pos)
piece = self.board.get_piece(row, col)
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
return True
return False
def _move(self, row, col):
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
if skipped:
self.board.remove(skipped)
self.change_turn()
else:
return False
return True
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 15)
def change_turn(self):
self.valid_moves = []
if self.turn == WHITE:
self.turn = BLACK
else:
self.turn = WHITE
def winner(self):
return self.board.winner()
def draw(self):
for row in self.board.board:
for piece in row:
if piece != 0 and piece.color == self.turn and len(
self.board.get_valid_moves(piece)) > 0:
return self.draw
self.draw = True
return self.draw
def get_board(self):
return self.board
def highlight_move(self, new_board):
old_board = self.board
for row in range(ROWS):
for col in range(COLS):
if old_board.board[row][
col] == 0 and new_board.board[row][col] != 0:
pygame.draw.circle(self.win,
BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2),
40,
width=5)
if new_board.board[row][
col] == 0 and old_board.board[row][col] != 0:
pygame.draw.circle(self.win,
BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2),
40,
width=5)
pygame.display.update()
def ai_move(self, new_board):
self.highlight_move(new_board)
pygame.time.delay(1000)
self.board = new_board
self.change_turn()
class Game:
def __init__(self, win):
self._init()
self.win = win
def update(self):
self.board.draw(self.win)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
def _init(self):
self.selected = None
self.board = Board()
self.turn = RED
self.valid_moves = {}
def winner(self):
return self.board.winner()
def reset(self):
self._init()
def select(self, row, col):
if self.selected:
result = self._move(row, col)
if not result:
self.selected = None
self.select(row, col)
piece = self.board.get_piece(row, col)
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
return True
return False
def _move(self, row, col):
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
if skipped:
self.board.remove(skipped)
self.change_turn()
else:
return False
return True
def get_board(self):
return self.board
def ai_move(self, board):
#will be passed the changed board the entire board will be returned and the board the player sees will
#be updated to include the new board
self.board = board
self.change_turn()
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 15)
def change_turn(self):
self.valid_moves = {}
if self.turn == RED:
self.turn = WHITE
else:
self.turn = RED
class Game:
def __init__(self, win):
self._init()
self.win = win
def update(self):
self.board.draw(self.win)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
def _init(self):
self.selected = None
self.human_player = False
self.board = Board()
self.turn = RED
self.valid_moves = {}
self.display_buttons()
def multiplayer(self):
self.human_player = True
def singleplayer(self):
self.human_player = False
def display_buttons(self):
game_reset = tk.Button(root, text='New Game ', image=newgame, compound=TOP, font='Raleway', command=self.reset,
relief=GROOVE)
game_reset.place(relx=0.2, rely=0.6)
multiplayer = tk.Button(root, text='Multiplayer ', image=multi, compound=TOP, font='Raleway',
command=self.multiplayer, relief=GROOVE)
multiplayer.place(relx=0.2, rely=0.72)
singleplayer = tk.Button(root, text='Singleplayer', image=single, compound=TOP, font='Raleway',
command=self.singleplayer, relief=GROOVE)
singleplayer.place(relx=0.2, rely=0.84)
def winner(self):
return self.board.winner()
def reset(self):
self._init()
def select(self, row, col):
if self.selected:
result = self._move(row, col)
if not result:
self.selected = None
self.select(row, col)
piece = self.board.get_piece(row, col)
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_legal_moves(piece)
return True
return False
def _move(self, row, col):
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
if skipped:
self.board.remove(skipped)
self.change_turn()
else:
return False
return True
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
self.win.blit(circle, (col * square_size + 25, row * square_size + 25))
def change_turn(self):
self.valid_moves = {}
if self.turn == RED:
self.turn = WHITE
else:
self.turn = RED
def get_board(self):
return self.board
def algorithm_move(self, board):
self.board = board
self.change_turn()
class Game:
def __init__(self, win):
self._init()
self.win = win
def update(self):
self.board.draw(self.win)
self.draw_valid_moves(self.valid_moves)
# pygame.draw.circle(win, GREY, (self.x, self.y), radius+self.OUTLINE)
pygame.display.update()
def _init(self):
self.selected = None
self.board = Board()
self.turn = RED
self.valid_moves = {}
def winner(self):
return self.board.winner()
def reset(self):
self._init()
self.board.draw(self.win)
pygame.display.update()
def select(self, row, col, win):
if self.selected:
result = self._move(row, col)
if not result:
self.selected = None
self.select(row, col, win)
piece = self.board.get_piece(row, col)
if piece != 0 and piece.color == self.turn:
# print(piece.x, piece.y)
# pygame.draw.circle(win, GREEN, (piece.x, piece.y), 15)
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
return True
return False
def _move(self, row, col):
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
if skipped:
self.board.remove(skipped)
self.change_turn()
else:
return False
return True
def draw_valid_moves(self, moves):
# print(self.selected)
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE +
SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 15)
def change_turn(self):
self.valid_moves = {}
if self.turn == RED:
self.turn = BLACK
else:
self.turn = RED
def get_board(self):
return self.board
def ai_move(self, board):
self.board = board
self.change_turn()
class Game:
def __init__(self, win):
self._init()
self.win = win
def update(self):
self.board.draw(self.win)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
def _init(self):
self.selected = None
self.board = Board()
self.turn = RED
self.valid_moves = {}
def reset(self):
self._init()
def select(self, row, col):
if self.selected:
result = self._move(row, col)
if not result:
self.selected = None
self.select(row, col)
piece = self.board.get_piece(row, col)
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
print(self.valid_moves)
return True
return False
def _move(self, row, col):
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
self.change_turn()
else:
return False
return True
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLACK,
(col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 15)
def change_turn(self):
self.valid_moves = {}
if self.turn == BLUE:
self.turn = RED
else:
self.turn = BLUE
def validate_winner(self, row, col, color):
piece = self.board.get_piece(row, col)
if piece != 0:
if piece.color == color:
return True
return False
def winner(self):
r0_c0 = self.validate_winner(0, 0, RED)
r1_c0 = self.validate_winner(1, 0, RED)
r0_c1 = self.validate_winner(0, 1, RED)
r1_c1 = self.validate_winner(1, 1, RED)
r0_c2 = self.validate_winner(0, 2, RED)
r2_c0 = self.validate_winner(2, 0, RED)
r0_c3 = self.validate_winner(0, 3, RED)
r3_c0 = self.validate_winner(3, 0, RED)
r2_c1 = self.validate_winner(2, 1, RED)
r1_c2 = self.validate_winner(1, 2, RED)
if r0_c0 and r1_c0 and r0_c1 and r1_c1 and r0_c2 and r2_c0 and r0_c3 and r3_c0 and r2_c1 and r1_c2:
print('#########################################')
print('######### Gano el Jugador ROJO ##########')
print('#########################################')
return RED
r8_c8 = self.validate_winner(8, 8, BLUE)
r7_c8 = self.validate_winner(7, 8, BLUE)
r8_c7 = self.validate_winner(8, 7, BLUE)
r7_c7 = self.validate_winner(7, 7, BLUE)
r8_c6 = self.validate_winner(8, 6, BLUE)
r6_c8 = self.validate_winner(6, 8, BLUE)
r8_c5 = self.validate_winner(8, 5, BLUE)
r5_c8 = self.validate_winner(5, 8, BLUE)
r6_c7 = self.validate_winner(6, 7, BLUE)
r7_c6 = self.validate_winner(7, 6, BLUE)
if r8_c8 and r7_c8 and r8_c7 and r7_c7 and r8_c6 and r6_c8 and r8_c5 and r5_c8 and r6_c7 and r7_c6:
print('#########################################')
print('######### Gano el Jugador AZUL ##########')
print('#########################################')
return BLUE
return None
def get_board(self):
return self.board
def ai_move(self, board):
self.board = board
self.change_turn()
class Game:
def __init__(self, win):
self._init()
self.win = win
def update(self):
self.board.draw(self.win)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
def _init(self):
self.selected = None
self.board = Board()
self.turn = WHITE
self.valid_moves = {}
def winner(self):
return self.board.winner()
def reset(self):
self._init()
def select(self, row, col):
if self.selected:
result = self._move(row, col)
if not result:
self.selected = None
self.select(row, col)
piece = self.board.get_checker(row, col)
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
return True
return False
def _move(self, row, col):
piece = self.board.get_checker(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
if skipped:
self.board.remove(skipped)
self.change_turn()
else:
return False
return True
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
pygame.draw.rect(self.win, GREEN, (col * SQUARE_SIZE, row * SQUARE_SIZE, SQUARE_SIZE, SQUARE_SIZE))
def change_turn(self):
self.valid_moves = {}
if self.turn == WHITE:
self.turn = BLACK
else:
self.turn = WHITE
class Game:
def __init__(self, win):
self._init()
self.win = win
def update(self):
self.board.draw(self.win)
self.draw_valid_moves(self.valid_moves) # to increase difficulty let deactivate this function
pygame.display.update()
def _init(self):
self.selected = None
self.board = Board()
self.turn = GREEN
self.valid_moves = {}
def winner(self):
return self.board.winner()
def reset(self):
self._init()
def select(self, row, col):
if self.selected:
result = self._move(row, col)
if not result:
self.selected = None
self.select(row, col)
piece = self.board.get_piece(row, col)
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
return True
return False
def _move(self, row, col):
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
# if skipped:
# self.board.remove(skipped)
self.change_turn()
else:
return False
return True
# to increase difficulty let deactivate this function():
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE//2, row * SQUARE_SIZE + SQUARE_SIZE//2), 15)
def change_turn(self):
self.valid_moves = {}
if self.turn == GREEN:
self.turn = WHITE
else:
self.turn = GREEN
class Game:
def __init__(self, window):
self._init()
self.window = window # the Game window on your device
def update(self):
self.board.draw(self.window)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
def _init(self):
self.selected = None # which piece is selected
self.board = Board(
) # the game will happen on the board so we initialize it inside the Game class
self.turn = YELLOW # which player's turn
self.valid_moves = {
} # what the current valid moves are for whatever player is playing
# to reinitialize the game
def reset(self):
self._init()
def winner(self):
return self.board.winner()
def select(self, row, col): # this is a recursive method
if self.selected: # in case user pressed on some piece
result = self._move(row, col)
# move the selected piece from row and col of the select method to row and col of the move method
if not result: # if the result is not valid (an empty square selected for example)
self.selected = None # nothing is selected
self.select(
row, col
) # user has to select a new piece (so this is to call the method again)
piece = self.board.get_piece(
row, col) # define the piece correspond to selected row and col
if piece != 0 and piece.color == self.turn:
# if the selected piece exists and corresponds to the player's color:
self.selected = piece # the piece is selected
self.valid_moves = self.board.get_valid_moves(piece)
return True # the selection is valid
return False # the selected piece is not valid, try again
def _move(self, row, col):
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
#(piece == 0 to make sure that where we are going to move the piece is an empty square with no piece on it already!)
self.board.move(self.selected, row,
col) # move the valid selected piece
skipped = self.valid_moves[(row, col)]
if skipped:
self.board.remove(
skipped) # remove the eaten pieces from the board
self.change_turn() # change turn so the second player can play
else:
return False
return True
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
# since moves is a dictionary of tuples (row, col)
pygame.draw.circle(self.window,
BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2),
radius=15)
def change_turn(self):
self.valid_moves = {}
if self.turn == WHITE:
self.turn = YELLOW
else:
self.turn = WHITE
class Game:
def __init__(self, win):
'''
de facto wywolanie _init() przypisanie zmiennej win która jest naszym oknem
'''
self.win = win
self._init()
def update(self):
'''
funkcja update uruchamiana w każdym obiegu głównej funkcji main,
rysuje ustawienie szachownicy jak i samą szachownicę
dozwolone ruchy o ile istnieją
po części obłsuguje wyjątki poprzez printowanie tekstów "wywoływanych" przez wyjątki za pomocą zmiany stanów zmiennych
kontrolowanie czy któryś z graczy nie wygrał meczu poprzez sprawdzanie zmienne winner, jesli tak obsługuje
printa z informacja kto wygrał
'''
self.board.draw(self.win)
self.printing_moves()
self.draw_valid_moves(self.valid_moves)
if self.bad_move_exce:
self.bad_move_exe()
pygame.time.delay(1000)
self.bad_move_exce = False
if self.outside_board_exce:
self.outside_board_exe()
pygame.time.delay(1000)
self.outside_board_exce = False
if self.winner() != None:
if self.winner() == WHITE:
pygame.draw.rect(
self.win, GREY,
(1 * SQUARE_SIZE + SQUARE_SIZE // 2, 4 * SQUARE_SIZE,
5 * SQUARE_SIZE, SQUARE_SIZE + 5))
self.show_text("WHITE HAS WON", 4, 1.5, WHITE)
else:
pygame.draw.rect(
self.win, GREY,
(1 * SQUARE_SIZE + SQUARE_SIZE // 2, 4 * SQUARE_SIZE,
5 * SQUARE_SIZE, SQUARE_SIZE + 5))
self.show_text("RED HAS WON", 4, 2, WHITE)
pygame.display.update()
def show_text(self, content, x, y, rgb):
'''
printowanie tekstu o zadanym kolorze rgb na ekranie w konkretnym miejscu
'''
text = FONT2.render(content, True, rgb)
self.win.blit(text, (y * SQUARE_SIZE + SQUARE_SIZE // 4 + 5,
x * SQUARE_SIZE + SQUARE_SIZE // 4 + 5))
def _init(self):
'''
de facto funkcja inicjalizująca wywoływana w __init__(), było to potrzebne aby łatwo robić resety
mamy takie parametry jak selected - zaznaczony item (typu zwykła bierka/król)
stworzenie obiektu Board (nasza plansza)
aktualna tura
dostępne ruchy do funkcji valid_moves
pola dla wyjątków do obsługi nieco zawiłej procedury printowania wyjątków na ekranie gry pygame
'''
self.selected = None
self.board = Board(self.win)
self.turn = RED
self.valid_moves = {}
self.bad_move_exce = False
self.outside_board_exce = False
def reset(self):
'''
resetowanie gry poprzez ponowne wywołanie funkcji _init()
:return:
'''
self._init()
def select(self, row, col):
'''
wybranie konkretnego itemu z naszej tablicy (szachownica ma dostępne pola 0 - puste, Piece - obiekt podsatwowej bierki, King - bierka król)
wybieranie przebiega na podsatwie zmiennych row,col które symbolizują pola 8x8 planszy
obsługa dwóch wyjątków - łapanie wyjątku odnośnie "bad move" kliknięcie podczas tury ruchu pole które nie jest dozwolonym ruchem
oraz podnoszenie wyjątku o kliknięciu w dolny pasek który nie jest responsywny a jest jedynie tłem
w dodatku metoda obsługuje restart gry gdy przekazane współrzędne odpowiadają naszemu przyciskowi
'''
if row != 8:
# jeśli mamy już coś zaznaczonego (bierkę) próbujemy zrobić ruch
if self.selected:
try:
result = self._move(row, col)
if not result:
self.selected = None
self.select(row, col)
except BadMoveExceptions:
self.bad_move_exce = True
print("bad move")
# pobieramy wartość z pod konkretnego indeksu na tablicy
piece = self.board.get_piece(row, col)
# jeżeli obiekt != znaczy ze jest to jakaś bierka, sprawdzamy czy to nasza tura
# i czy mamy jakieś ruchy dla tej konkretnej instacji (bierki)
# jeśli tak zracamy true, jesli nie false
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
return True
elif piece != 0 and piece.color != self.turn:
print("zly kolor")
return False
# jeżeli klikniecie jest w 8 rząd czyli poniżej planszy (0-7 rzędy) sprawdzamy czy kliknęliśmy w guzik
elif col == 0 or col == 1:
self.restart_game()
# jeśli kliknęlismy poza plansze ale nie w guzik wyrzucamy błąd
else:
raise OutsideBoardExceptions()
def bad_move_exe(self):
'''
obsługa printu dla niedozwolonego ruchu
'''
pygame.draw.rect(self.win, GREY,
(1 * SQUARE_SIZE + SQUARE_SIZE // 2, 4 * SQUARE_SIZE,
5 * SQUARE_SIZE, SQUARE_SIZE + 5))
self.show_text("BAD MOVE", 4, 1.5, BLACK)
def outside_board_exe(self):
'''
obsługa printu dla kliknięcie poza obszar planszy który jednak dalej jest w oknie gry
'''
pygame.draw.rect(self.win, GREY,
(1 * SQUARE_SIZE + SQUARE_SIZE // 2, 4 * SQUARE_SIZE,
5 * SQUARE_SIZE, SQUARE_SIZE + 5))
self.show_text("Outside board", 4, 1.5, BLACK)
def restart_game(self):
'''
metoda restartująca poprzez ponowne wywołanie inita który inicjalizuje wartości
'''
print("restart")
self._init()
def _move(self, row, col):
'''
metoda sprawdzająca czy czy pod podanymi współrzędnymi znajduje się się 0 czyli brak jakiegoś obiektu i
czy można tam przestawić naszą bierkę
'''
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
if skipped:
self.board.remove(skipped)
self.change_turn()
else:
if piece == 0:
raise BadMoveExceptions()
return True
def change_turn(self):
'''
metoda która zmienia turę bazując na obecnej turze
:return:
'''
self.valid_moves = {}
if self.turn == RED:
self.turn = WHITE
elif self.turn == WHITE:
self.turn = RED
def draw_valid_moves(self, moves):
'''
na podstawie elementów w valid_moves = możliwe ruchy rysujemy niebieskie kropki w tych punktach
'''
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 12)
def winner(self):
'''
metoda zwracająca zwycięzce na podstawie zmiennych zawartych w klasie
'''
return self.board.winner()
def printing_moves(self):
'''
obsługa printowania tury gracza na dole ekranu z grą
'''
if self.turn == RED:
self.show_text("RED's MOVE", 7.8, 2, BLACK)
else:
self.show_text("WHITE's MOVE", 7.8, 2, BLACK)
class Game:
def __init__(self, win):
self._init()
self.win = win
def update(self):
self.board.draw(self.win)
self.drawValidMoves(self.validMoves)
pygame.display.update()
def _init(self):
self.selected = None
self.board = Board()
self.turn = creamWhite
self.validMoves = {}
def winner(self):
return self.board.winner()
def reset(self):
self._init()
def select(self, row, col):
if self.selected:
result = self._move(row, col)
if not result:
self.selected = None
self.select(row, col)
piece = self.board.getPiece(row, col)
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.validMoves = self.board.getValidMoves(piece)
return True
return False
def _move(self, row, col):
piece = self.board.getPiece(row, col)
if self.selected and piece == 0 and (row, col) in self.validMoves:
self.board.move(self.selected, row, col)
skipped = self.validMoves[(row, col)]
if skipped:
self.board.remove(skipped)
self.changeTurn()
else:
return False
return True
def drawValidMoves(self, moves):
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 15)
def changeTurn(self):
self.validMoves = {}
if self.turn == creamWhite:
self.turn = WHITE
else:
self.turn = creamWhite
def getBoard(self):
return self.board
def aiMove(self, board):
self.board = board
self.changeTurn()
class Game:
def __init__(self, win):
self._init()
self.win = win
def update(self):
self.board.draw(self.win)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
# _init makes it a private method of the class
def _init(self):
self.selected = None
self.board = Board()
self.turn = RED
self.valid_moves = {}
def winner(self):
return self.board.winner()
def reset(self):
self._init()
def select(self, row, col):
if self.selected:
result = self._move(row, col)
if not result:
self.selected = None
self.select(row, col)
piece = self.board.get_piece(row, col)
if piece != 0 and piece.color == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
return True
return False
def _move(self, row, col):
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
if skipped:
self.board.remove(skipped)
self.change_turn()
else:
return False
return True
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE,
(col * SQUARE_SIZE + SQUARE_SIZE // 2,
row * SQUARE_SIZE + SQUARE_SIZE // 2), 15)
def change_turn(self):
self.valid_moves = {}
if self.turn == RED:
self.turn = WHITE
else:
self.turn = RED
class Game:
def __init__(self, win):
self._init()
self.win = win
#updates the display and draws it
def update(self):
self.board.draw(self.win)
self.draw_valid_moves(self.valid_moves)
pygame.display.update()
def _init(self):
self.selected = None
self.board = Board()
self.turn = RED
self.valid_moves = {}
#if someone wins the game
def winner(self):
return self.board.winner()
#method to reset the game
def reset(self):
self._init()
#if selection is valid, move the piece
#otherwise reset the selection and reselect a row and col
def select(self, row, col):
if self.selected:
result = self.move(row, col)
if not result:
self.selected = None
self.select(row, col)
piece = self.board.get_piece(row, col)
if piece != 0 and piece.colour == self.turn:
self.selected = piece
self.valid_moves = self.board.get_valid_moves(piece)
return True
return False
def move(self, row, col):
piece = self.board.get_piece(row, col)
if self.selected and piece == 0 and (row, col) in self.valid_moves:
self.board.move(self.selected, row, col)
skipped = self.valid_moves[(row, col)]
if skipped:
self.board.remove(skipped)
self.change_turn()
else:
return False
return True
def draw_valid_moves(self, moves):
for move in moves:
row, col = move
pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE//2, row * SQUARE_SIZE + SQUARE_SIZE//2), 15)
#if red turn, change to black, else change to red
def change_turn(self):
self.valid_moves = {}
if self.turn == RED:
self.turn = BLACK
else:
self.turn = RED
def get_board(self):
return self.board
def ai_move(self, board):
self.board = board
self.change_turn()
