def _init(self):
self.selected = None
self.human_player = False
self.board = Board()
self.turn = RED
self.valid_moves = {}
self.display_buttons()
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
def __init__(self, win):
self._init()
self.selected = None
self.board = Board()
self.turn = RED
self.valid_moves = {}
self.win = win
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 = {}
def simulate(self,
bot_white,
bot_black,
print_game=False,
starting_player=Player.white):
"""Simulates a number of games by two agents.
Parameters
-----------
bot_white : Bot
Bot that will play for the white side.
bot_black : Bot
Bot that will play for the black side.
print_game : boolean (Default = False)
If it's True it will print the board at each move.
If it is not, then no board would be printed.
starting_player : Player
The player who would make the first move.
"""
for _ in range(self.num_of_games):
board = Board()
self.display.assign_board(board)
current_turn = starting_player
winner = None
while winner is None:
choice = []
if current_turn == Player.white:
choice = bot_white.select_move(board)
else:
choice = bot_black.select_move(board)
board.make_move(choice)
winner = board.has_winner()
if print_game:
self.display.print_board()
# Uncomment to see the number of pieces left
# self.display.print_pieces_left()
current_turn = current_turn.other
if winner is Player.white:
self.white_wins += 1
print("White WIN")
elif winner is Player.black:
self.black_wins += 1
print("Black WIN")
elif winner == "Tie":
self.ties += 1
print("TIE")
print("White wins: " + str(self.white_wins))
print("Black wins: " + str(self.black_wins))
print("Ties: " + str(self.ties))
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
def main():
clock = pygame.time.Clock()
run = True
board = Board()
while (run):
clock.tick(fps)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.MOUSEBUTTONDOWN:
pass
board.draw(win)
pygame.display.update()
pygame.quit()
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 main():
run = True
clock = pygame.time.Clock()
board = Board()
while run:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.MOUSEBUTTONDOWN:
pass
board.draw(WIN)
pygame.display.update()
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()
def test_board_sets_up_tiles_correctly():
"""Trickier than it looks, row 1 is white ... row 2 is black... and that pattern repeats 4 times"""
colors = 4 * (4 * [Color.WHITE, Color.BLACK] +
4 * [Color.BLACK, Color.WHITE])
board = Board()
for i in range(64):
assert board.squares[i].color == colors[i]
def main():
"""
run this function to run the game.
event loop.
will run every x time per second and check if the player pressed on something and update the display
"""
run = True #boolean variable - remains true as long as there's no winner.
clock = pygame.time.Clock()
game = Game(WIN) #is for game window
board = Board()
difficultyLevel = get_level()
while run:
clock.tick(FPS)
if game.turn == WHITE: #there are two palyers: White and Red
value, new_board = minimax(game.get_board(), difficultyLevel + 1,
WHITE, game)
game.ai_move(new_board)
if game.winner() != None:
run = False
for event in pygame.event.get():
#check if events have happened at the current time
if event.type == pygame.QUIT:
run = False
if event.type == pygame.MOUSEBUTTONDOWN: #player press on mouse
pos = pygame.mouse.get_pos()
row, col = get_row_col_from_mouse(pos)
game.select(row, col)
pos = pygame.mouse.get_pos()
row, col = get_row_col_from_mouse(pos)
if (difficultyLevel < 3):
game.update_board(row, col)
else:
game.update3(row, col)
if game.winner() == WHITE:
messagebox.showinfo("Game Over", "White is Winner")
elif game.winner() == RED:
messagebox.showinfo("Game Over", "RED is Winner")
elif game.winner() == BLACK:
messagebox.showinfo("Game Over",
"Too many moves with no change\n Result: Draw")
elif game.winner() == PITCH:
messagebox.showinfo("Game Over",
"Red has no more valid moves\nWhite is Winner\n")
elif game.winner() == GRAY:
messagebox.showinfo("Game Over",
"White has no more valid moves\nRed is Winner\n")
pygame.quit() #close board window
def main():
run = True
clock = pygame.time.Clock()
board = Board()
game = Game(WIN)
piece = board.get_piece(0, 1)
while run:
clock.tick(FPS)
if game.winner() != None:
print(game.winner())
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)
game.select(row, col)
game.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'
def get_board_position_2d(self, player):
if self._player_1_board_position_2d is None:
result = np.tile(
0, [self.state.board_height(),
self.state.board_width()])
for piece in self.state.get_uncaptured_pieces():
x = int((piece.position - 1) / 4)
y = (piece.position - 1) % 4
value = (3 if piece.king else 1) * (1 if piece.player == 1 else
-1)
result[x, y] = value
self._player_1_board_position_2d = result
return self._player_1_board_position_2d if player == 1 else (
Board.flip_2d(self._player_1_board_position_2d) * -1)
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):
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 _init(self):
self.selected = None
self.board = Board()
self.turn = RED
self.valid_moves = {} #a dictionary of current vallid moves
def h_peices_num(board: Board, player_num):
return board.count_movable_player_pieces(player_num)
def _init(self):
self.selected = None
self.board = Board()
self.turn = creamWhite
self.validMoves = {}
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)
def _init(self):
self.selected = None
self.board = Board()
self.turn = RED
self.valid_moves = {}
def fake_board():
return Board(empty=True)
from checkers.board import Board
from checkers.player import *
# Constant
BOARD_DIMENSIONS = 8
NUM_OF_PIECES = 12
TILE_WIDTH = 1
TILE_HEIGHT = 1
# Initiate game variables and objects
gameOver = False
isBlackTurn = False
board = Board(8)
aiPlayer = AIPlayer(NUM_OF_PIECES, 'Black', board)
human = HomanPlayer(NUM_OF_PIECES, 'White', board)
while not gameOver:
# White (human) starts
board.win.getMouse() # just to keep the window open
human.play(board)
aiPlayer.play(board)
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
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()
# -*- 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)
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()
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
# 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()
