def test_get_rent(self):
chloe = Player("Chloe", 0)
lucien = Player("Lucien", 1)
gildas = Player("Gildas", 1)
board = Board()
chloe.buy_good(board.boxes[1])
board.boxes[1].nb_houses = 2
chloe.buy_good(board.boxes[3])
board.boxes[3].nb_houses = 3
chloe.buy_good(board.boxes[5])
chloe.buy_good(board.boxes[6])
chloe.buy_good(board.boxes[12])
gildas.buy_good(board.boxes[15])
gildas.buy_good(board.boxes[25])
lucien.dices = [3, 4]
self.assertEqual(0, board.boxes[1].get_rent(chloe))
self.assertEqual(0, board.boxes[8].get_rent(chloe))
self.assertEqual(0, board.boxes[16].get_rent(chloe))
self.assertEqual(30, board.boxes[1].get_rent(lucien))
self.assertEqual(180, board.boxes[3].get_rent(lucien))
self.assertEqual(50, board.boxes[5].get_rent(lucien))
self.assertEqual((3 + 4) * 4, board.boxes[12].get_rent(lucien))
self.assertEqual(0, board.boxes[13].get_rent(lucien))
self.assertEqual(100, board.boxes[15].get_rent(lucien))
def get_input(self, board):
# best_move = None
# best_score = -100 # TBD - perhaps use some partial scores to decide somewhat better moves
for i in range(0, board.shape[0]):
for j in range(0, board.shape[1]):
if board[i, j] != 0: continue
current_board = Board(array=board.copy())
current_player = self.player_no
current_board.move(i, j, self.player_no)
while not current_board.is_finished():
current_player = self.switch_player(current_player)
next_move = ScorePlayer(self.player_no).get_input(
current_board.board) # that's just one step
current_board.move(next_move[0], next_move[1],
current_player)
if current_board.player_who_won == self.player_no: # if game played was won by the Player, than finish search (no way to evaluate which wining strategy is better, for now ;P)
return [i, j]
return ScorePlayer(self.player_no).get_input(
board
) # we didn't find a winning solution, so fallback to simple 1-step score based
def testAi(self):
b = Board(False)
b.set_white(4, 0)
b.set_white(5, 0)
b.set_white(6, 0)
b.set_white(7, 0)
b.set_white(3, 4)
b.set_white(4, 4)
b.set_white(4, 3)
b.set_white(5, 3)
b.set_white(5, 1)
b.set_white(6, 1)
b.set_black(1, 5)
b.set_black(2, 0)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(3, 1)
b.set_black(3, 2)
b.set_black(3, 3)
b.set_black(4, 1)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(6, 2)
b.set_black(7, 1)
b.set_black(7, 2)
print(b.draw())
ai = AiController(0, WHITE)
move = ai.next_move(b)
#self.assertEqual(, )
self.assertIn(move,
[p.get_position() for p in b.get_move_pieces(WHITE)])
def test_create_board_from_another_one(self):
self.board.move_pawn((0, 1), PLAYER_1)
self.board.move_pawn((0, 2), PLAYER_2)
self.board.move_pawn((0, 2), PLAYER_3)
self.board.move_pawn((0, 2), PLAYER_4)
self.board.add_wall((1, 1), is_horiz=True, player=PLAYER_1)
self.board.add_wall((1, 2), is_horiz=True, player=PLAYER_2)
self.board.add_wall((1, 3), is_horiz=True, player=PLAYER_3)
self.board.add_wall((1, 4), is_horiz=True, player=PLAYER_4)
self.board.add_wall((2, 1), is_horiz=False, player=PLAYER_1)
self.board.add_wall((3, 1), is_horiz=False, player=PLAYER_2)
self.board.add_wall((4, 1), is_horiz=False, player=PLAYER_3)
self.board.add_wall((5, 1), is_horiz=False, player=PLAYER_4)
board2 = Board(self.board, len(self.board.pawns))
self.assertEqual(4, len(board2.pawns))
self.assertEqual(self.board.pawns, board2.pawns)
self.assertEqual(4, len(board2.goals))
self.assertEqual(self.board.goals, board2.goals)
self.assertEqual(4, len(board2.player_walls))
self.assertEqual(self.board.player_walls, board2.player_walls)
self.assertEqual(self.board.verti_walls, board2.verti_walls)
self.assertEqual(self.board.horiz_walls, board2.horiz_walls)
def __init__(self,
timeout=1,
display_moves=True,
players=['ai', 'ai'],
colour=False):
self.board = Board(colour)
self.timeout = timeout
self.ai_counter = 0
self.list_of_colours = [BLACK, WHITE]
self.players = players
self.display_moves = display_moves
self.controllers = deque([
self._make_controller(c, p)
for c, p in zip(self.list_of_colours, self.players)
])
self.player = self.controllers[0].get_colour()
self.board.set_black(4, 3)
self.board.set_black(3, 4)
self.board.set_white(4, 4)
self.board.set_white(3, 3)
self.board.mark_moves(self.player)
self.previous_move = None
self.previous_round_passed = False
def get_original_coordinate(self,
rotated_coordinate: Coordinate) -> Coordinate:
if len(self._history) == 0:
return rotated_coordinate
undo_board = Board()
undo_board.play(Board.COMPUTER, rotated_coordinate)
undo_rotator = Rotator(undo_board.get_matrix())
for i in reversed(range(len(self._history))):
move_to_undo = self._history[i]
if move_to_undo == self._FLIP_VER:
undo_rotator.flip_vertical()
elif move_to_undo == self._FLIP_HOR:
undo_rotator.flip_horizontal()
elif move_to_undo == self._ROTATE_CW:
undo_rotator.rotate_counter_clockwise()
elif move_to_undo == self._ROTATE_CCW:
undo_rotator.rotate_clockwise()
output = Coordinate()
output.set_from_pos(undo_rotator.get_rotated_matrix().find(
Board.COMPUTER))
return output
def test_init(self):
b = Board(False)
self.assertEqual(len(b.get_move_pieces(WHITE)), 0)
self.assertEqual(len(b.get_move_pieces(BLACK)), 0)
def __init__(self, players):
self.players = self.init_players(players)
self.board = Board()
self.players_order = self.order_players(self.players)
self.current_player_turn = 0
self.board.boxes[0].players = list(players.keys())
from game.board import Board
if __name__ == '__main__':
pawns = [[[1, 1], [2, 1], [3, 1]], [[1, 3], [2, 3], [3, 3]]]
bridges = []
for y in range(5):
for x in range(5):
if x < 4:
bridges.append((x, y, x + 1, y))
if y < 4:
bridges.append((x, y, x, y + 1))
b = Board(bridges, pawns)
bestMove = b.findBestMove()
newpawns = pawns[0].copy()
newpawns.remove([bestMove[0], bestMove[1]])
newpawns.append([bestMove[2], bestMove[3]])
newBoard = Board(bridges, [newpawns, pawns[1]])
bestBridge = newBoard.removeBestBridge()
newBridges = bridges.copy()
newBridges.remove(bestBridge)
newBoard = Board(newBridges, [newpawns, pawns[1]])
newBoard.printboard()
from data.constants import Constants from game.board import Board board = Board(Constants.NB_ROOMS, Constants.NB_CHARACTERS, Constants.NB_WEAPONS) board.start_game()
def restart():
global board, board_log
print 'Game restarts'
board = Board(0)
board_log = BoardLog()
redraw()
from kivy.uix.button import Button
from kivy.uix.image import Image
from kivy.uix.gridlayout import GridLayout
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.popup import Popup
from kivy.uix.label import Label
from kivy.core.window import Window
from game.engine.minimax import MiniMax
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.properties import NumericProperty
Window.size = (800, 600)
# TODO game over issues
source_tile = None
board = Board(0)
destination_tile = None
human_moved_piece = None
source_color = None
destination_color = None
mode = 0
whiteAI = None
blackAI = None
tile_panels = list()
flipped = False
alliance = Alliance.WHITE
def redraw():
for i in range(0, 64):
tile_panels[i].clear_widgets()
def main_game(genomes, config):
gameSpeed = 5
gameOver = False
nets = []
genomes_track = []
snakes = []
for _, genome in genomes:
net = neat.nn.FeedForwardNetwork.create(genome, config)
nets.append(net)
snake_initial_coord = unique_coords(snakes)
snakes.append(Snake(snake_initial_coord, gameSpeed))
genome.fitness = 0
genomes_track.append(genome)
#snake = Snake((int(BOARD_ROWS / 2), int(BOARD_COLS / 2)), gameSpeed)
tile_coord = unique_coords(snakes)
tile = Tile(tile_coord)
board = Board(screen)
score = Score(screen)
#last_obstacle = pygame.sprite.Group()
while not gameOver:
for event in pygame.event.get():
if event.type == QUIT:
gameOver = True
quit()
if event.type == KEYDOWN:
if event.key == K_UP:
for snake in snakes:
snake.move_up()
if event.key == K_DOWN:
for snake in snakes:
snake.move_down()
if event.key == K_RIGHT:
for snake in snakes:
snake.move_right()
if event.key == K_LEFT:
for snake in snakes:
snake.move_left()
for snake in snakes:
snake.update()
check_collide(snakes, tile, genomes_track, nets)
if tile.is_dead():
score.update()
#snake.eat_tile()
tile_coord = unique_coords(snakes)
tile = Tile(tile_coord)
if len(snakes) == 0:
gameOver = True
quit()
board.clean_board()
for snake in snakes:
board.display_snake(snake.get_body())
board.display_tile(tile.get_coord())
update_fitness(snakes, tile, genomes_track, nets)
if pygame.display.get_surface() != None:
screen.fill(BG_COLOR)
board.draw()
score.draw()
pygame.display.update()
clock.tick(FPS)
def index(request):
board = Board()
dictionary = WordDictionary("game/dictionary.txt")
solved = list(board.solve(dictionary))
return render(request, 'game/single_player_game.html', { 'board': board.board, 'solved': json.dumps(solved), 'json_board': json.dumps(board.board) })
class Game():
board = Board()
matriz = board.board
players = [None, None]
player = None
score = {
'x': 0,
'o': 0,
}
shift = 0
def __init__(self):
print('\t ** Welcome to the Checkers Game! ** ')
self.create_players()
def start(self):
self.board.show_matriz()
self.round()
def create_players(self):
self.players[0] = Player('Player 1', 'o')
self.players[1] = Player('Player 2', 'x')
def define_player(self):
if self.shift % 2 == 0:
self.player = self.players[0]
else:
self.player = self.players[1]
print('~> Player {} move the piece {}, shift {}'.format(
str(self.player), self.player.char, self.shift + 1))
def verify_move(self, casa_atual, casa_nova):
atual_line, atual_col = self.detach_item(casa_atual)
new_line, new_col = self.detach_item(casa_nova)
if new_line == atual_line or atual_col == new_col:
print('!!! WRONG MOVE !!! Try again')
return False
if self.matriz[atual_line][atual_col] == 'o':
if not (new_line == atual_line - 1):
print('!!! WRONG MOVE !!!')
return False
if self.matriz[new_line][new_col] == ' ':
if atual_col + 1 == new_col or atual_col - 1 == new_col:
self.matriz[new_line][new_col] = 'o'
self.matriz[atual_line][atual_col] = ' '
if new_line == 1:
print(
'\t\t --> Congratulations {}, now you have a King'.
format(str(self.player)))
self.matriz[new_line][new_col] = 'O'
return True
elif self.matriz[new_line][new_col].lower() == 'x':
unidade = -1 if new_col < atual_col else 1
if self.matriz[new_line + unidade][new_col + unidade] == ' ':
self.matriz[new_line][new_col] = ' '
self.matriz[new_line + unidade][new_col + unidade] = 'o'
self.count_point()
if new_line == 1:
print(
'\t\t --> Congratulations {}, now you have a King'.
format(str(self.player)))
self.matriz[new_line][new_col] = 'O'
return True
print('!!! WRONG MOVE !!!')
return False
elif self.matriz[atual_line][atual_col] == 'x':
if not (new_line == atual_line + 1):
print('!!! WRONG MOVE !!!')
return False
if self.matriz[new_line][new_col] == ' ':
if atual_col + 1 == new_col or atual_col - 1 == new_col:
self.matriz[new_line][new_col] = 'x'
self.matriz[atual_line][atual_col] = ' '
if new_line == 8:
print('Congratulations player 2, now you have a King')
self.matriz[new_line][new_col] = 'X'
return True
elif self.matriz[new_line][new_col].lower() == 'o':
unidade = -1 if new_col < atual_col else 1
if self.matriz[new_line + unidade][new_col + unidade] == ' ':
self.matriz[new_line][new_col] = ' '
self.matriz[atual_line][atual_col] = ' '
self.matriz[new_line + unidade][new_col + unidade] = 'x'
self.count_point()
if new_line == 1:
print('Congratulations player 2, now you have a King')
self.matriz[new_line][new_col] = 'X'
return True
print('!!! WRONG MOVE !!!')
return False
elif self.matriz[atual_line][atual_col] == 'O':
return self.king_walk('O', casa_atual, casa_nova)
elif self.matriz[atual_line][atual_col] == 'X':
return self.king_walk('X', casa_atual, casa_nova)
def king_walk(self, item, casa_atual, casa_nova):
atual_line, atual_col = self.detach_item(casa_atual)
new_line, new_col = self.detach_item(casa_nova)
total_lines = atual_line - new_line
total_cols = atual_col - new_col
step_lines = -1 if total_lines > 0 else 1
step_cols = -1 if total_cols > 0 else 1
aux_col, aux_line = atual_col, atual_line
if abs(total_lines) != abs(total_cols):
print('!!! WRONG MOVE !!!')
return False
for _ in range(abs(total_lines)):
aux_col += step_cols
aux_line += step_lines
if self.matriz[aux_line][aux_col] == ' ':
continue
if self.matriz[aux_line][aux_col].lower() != item.lower():
self.matriz[aux_line][aux_col] = ' '
new_line = new_line + step_lines
new_col = new_col + step_cols
self.count_point()
continue
break
else:
self.matriz[new_line][new_col] = item
self.matriz[atual_line][atual_col] = ' '
return True
print('!!! WRONG MOVE !!!')
return False
def count_point(self):
self.score[self.player.char] += 1
self.player.points += +1
print('~> Congratulations, {}! You get it.'.format(str(self.player)))
def verify_game_over(self):
items = 0
for line, _ in enumerate(self.matriz):
for column, _ in enumerate(self.matriz[line]):
if self.matriz[line][column] in ('x', 'X') or \
self.matriz[line][column] in ('o', 'O'):
items += 1
if items <= 3:
print('\t\t ~~~~~ GAME OVER ~~~~~')
self.game_over()
def game_over(self):
x = self.score['x']
o = self.score['o']
print('\n\t***\n\t\tPontuação: Jogador 1: {}, Jogador 2: {}'.format(
o, x))
if o > x:
print('Jogador 1 venceu com {} pontos!'.format(x))
else:
print('Jogador 2 venceu com {} pontos!'.format(o))
exit()
def round(self):
self.define_player()
line = None
column = None
verify_player = False
while verify_player is False:
initial_piece = input('Qual peça você gostaria de movimentar? ')
line, column = self.detach_item(initial_piece)
peca = self.matriz[line][column]
validate_player = self.validate_player(peca)
if validate_player is False:
continue
print('Para onde você gostaria de mover sua peça?')
# self.hint_move(line, column)
atual_piece = input('Digite no console sua resposta: ')
if self.verify_move(initial_piece, atual_piece) is True:
break
self.count_shift()
self.verify_game_over()
self.start()
def hint_move(self, line, column):
piece = self.matriz[line][column]
for key, val in self.board.letters.items():
if piece == 'o':
if val == line - 1:
option = key
if not column + 1 >= 9:
print('Você tem a opção de: \n\t => {}{}'.format(
option, column + 1))
if not column - 1 <= 0:
print('Você tem a opção de: \n\t => {}{}'.format(
option, column - 1))
if piece == 'x':
if val == line + 1:
option = key
if not column + 1 >= 9:
print('Você tem a opção de: \n\t => {}{}'.format(
option, column + 1))
if not column - 1 <= 0:
print('Você tem a opção de: \n\t => {}{}'.format(
option, column - 1))
if piece in ('O', 'X'):
break
def validate_player(self, peca):
if self.player.char == peca.lower():
return True
else:
print('!!! Desculpe, mas esse movimento é impropio. Sua peça é a '
'"{}" e você está tentando mover é a {}.'.format(
self.player.char, peca))
return False
def detach_item(self, coordenadas):
try:
return self.board.letters[coordenadas[0]], int(coordenadas[1])
except KeyError:
print('>>> Por favor, tente uma coordenada válida!')
return ('q', 'q')
def count_shift(self):
self.shift += 1
def test__check_geometry(faker):
width = faker.pyint(min_value=1, max_value=100)
height = faker.pyint(min_value=1, max_value=100)
array = Board(width=width, height=height).to_array()
assert len(array) == height
assert all(len(line) == width for line in array)
def board(faker):
return Board(
width=faker.pyint(min_value=4, max_value=100),
height=faker.pyint(min_value=4, max_value=100),
)
# Cargar players
players = []
filesToLoad = ["jugador_lab1", "random_metrics_2_100_tanh_invscaling", "self_metrics_2_100_logistic_constant"]
for files in filesToLoad:
p = archiver.loadPlayer(files, True)
if p != None:
players.append(p)
# Elegir oponente
playerIndex = gui.pickPlayer(players)
player = players[playerIndex-1]['player']
game_ended = False
b = Board()
opts = ['Hexagonal', 'Coordenadas', 'Matriz']
# Linea 1
buttonsText = Label(value='Representación del tablero:',
layout=Layout(margin='0px 16px 0px 0px'))
buttons = ToggleButtons(
options=opts,
disabled=False,
button_style='info', # 'success', 'info', 'warning', 'danger' or ''3
)
box0_layout = Layout(display='flex',
flex_flow='row',
margin='16px 0px 32px 0px',
width='100%')
def restart():
global board, tile_panels
board = Board(0)
for i in range(0, 64):
tile_panels[i].clear_widgets()
draw_board(0)
def setUp(self):
self.size = 20
self.board = Board(self.size)
for x in range(self.size):
for y in range(self.size):
self.board.set_element(x, y, x * 100 + y)
def __init__(self):
self.board = Board()
def __init__(self, human_color, computer_color):
self.game_board = Board()
self.whos_turn_is_it = 'black'
self.game_over = None
self.computer_player = Random_Choice_Player(computer_color)
self.human_player = Human_Player(human_color)
def setUp(self) -> None:
self.board = Board(self.input_board)
def new(self):
self.board = Board()
self.round = 0
self.winner = None
def __init__(self):
self.game_board = Board()
self.whos_turn_is_it = 'black'
self.game_over = None
def __init__(self):
self.board = Board()
self.round = 0
self.winner = None
self.x_points = 0
self.o_points = 0
def __init__(self, ai_player: int = 1) -> None:
self._board = Board(ai_player)
self._turn = 0
self._ai_player = ai_player
def test_get_number_of_companies(self):
chloe = Player("Chloe", 0)
board = Board()
chloe.buy_good(board.boxes[12])
self.assertEqual(1, chloe.get_number_of_companies())
def test_draw(self):
b = Board(False)
b.set_black(0, 0)
b.set_black(1, 0)
b.set_white(1, 1)
b.set_move(0, 1)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 BBBB............1
2 MMWW............2
3 ................3
4 ................4
5 ................5
6 ................6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b.clear_moves()
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 BBBB............1
2 ..WW............2
3 ..MMMM..........3
4 ................4
5 ................5
6 ................6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b.clear_moves()
b = Board(False)
b.set_white(3, 3)
b.set_white(3, 4)
b.set_white(4, 4)
b.set_white(4, 3)
b.set_black(2, 2)
b.set_black(3, 2)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(2, 3)
b.set_black(5, 3)
b.set_black(2, 4)
b.set_black(5, 4)
b.set_black(2, 5)
b.set_black(3, 5)
b.set_black(4, 5)
b.set_black(5, 5)
b.clear_moves()
b.mark_moves(WHITE)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ..MMMMMMMMMMMM..2
3 ..MMBBBBBBBBMM..3
4 ..MMBBWWWWBBMM..4
5 ..MMBBWWWWBBMM..5
6 ..MMBBBBBBBBMM..6
7 ..MMMMMMMMMMMM..7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 3)
b.set_white(4, 4)
b.set_black(3, 4)
b.set_black(4, 3)
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ......MM........3
4 ....MMWWBB......4
5 ......BBWWMM....5
6 ........MM......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
b.clear_moves()
b.make_move((3, 2), BLACK)
b.mark_moves(WHITE)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ....MMBBMM......3
4 ......BBBB......4
5 ....MMBBWW......5
6 ................6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
b.clear_moves()
b.make_move((2, 2), WHITE)
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ..MMWWBB........3
4 ....MMWWBB......4
5 ......BBWWMM....5
6 ........MM......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
b = Board(False)
b.set_white(6, 0)
b.set_white(5, 1)
b.set_white(3, 1)
b.set_white(3, 2)
b.set_white(4, 2)
b.set_white(5, 2)
b.set_white(3, 3)
b.set_white(4, 3)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(3, 4)
b.set_black(4, 4)
b.set_black(1, 5)
b.set_black(4, 5)
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ......MM....WW..1
2 ......WWMMWWMM..2
3 ....MMWWWWWW....3
4 ....BBWWWWMM....4
5 ....BBBBBB......5
6 ..BB....BB......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 4)
b.set_white(4, 0)
b.set_white(4, 3)
b.set_white(4, 4)
b.set_white(5, 0)
b.set_white(5, 1)
b.set_white(5, 3)
b.set_white(6, 0)
b.set_white(6, 1)
b.set_white(7, 0)
b.set_black(2, 0)
b.set_black(3, 1)
b.set_black(4, 1)
b.set_black(7, 1)
b.set_black(3, 2)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(6, 2)
b.set_black(7, 2)
b.set_black(3, 3)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(1, 5)
b.mark_moves(BLACK)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB..WWWWWWWW1
2 ......BBBBWWWWBB2
3 ......BBBBBBBBBB3
4 ....BBBBWWWWMM..4
5 ....BBWWWWMMMM..5
6 ..BBMMMMMMMM....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 4)
b.set_white(4, 0)
b.set_white(4, 3)
b.set_white(4, 4)
b.set_white(5, 0)
b.set_white(5, 1)
b.set_white(5, 3)
b.set_white(6, 0)
b.set_white(6, 1)
b.set_white(7, 0)
b.set_black(2, 0)
b.set_black(3, 1)
b.set_black(4, 1)
b.set_black(7, 1)
b.set_black(3, 2)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(6, 2)
b.set_black(7, 2)
b.set_black(3, 3)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(1, 5)
b.mark_moves(BLACK)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB..WWWWWWWW1
2 ......BBBBWWWWBB2
3 ......BBBBBBBBBB3
4 ....BBBBWWWWMM..4
5 ....BBWWWWMMMM..5
6 ..BBMMMMMMMM....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 2)
b.set_white(4, 1)
b.set_white(4, 2)
b.set_white(5, 1)
b.set_white(5, 2)
b.set_white(6, 0)
b.set_white(6, 1)
b.set_white(6, 2)
b.set_white(6, 3)
b.set_black(1, 3)
b.set_black(1, 5)
b.set_black(2, 0)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(3, 1)
b.set_black(3, 3)
b.set_black(3, 4)
b.set_black(3, 5)
b.set_black(4, 3)
b.set_black(4, 4)
b.set_black(5, 3)
b.set_black(5, 5)
b.set_black(6, 4)
b.set_black(7, 0)
b.mark_moves(BLACK)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB..MMMMWWBB1
2 ....MMBBWWWWWWMM2
3 ......WWWWWWWW..3
4 ..BBBBBBBBBBWWMM4
5 ....BBBBBB..BB..5
6 ..BB..BB..BB....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b.clear_moves()
b.mark_moves(WHITE)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ....BBMM....WWBB1
2 ....MMBBWWWWWW..2
3 ......WWWWWWWW..3
4 MMBBBBBBBBBBWW..4
5 ..MMBBBBBBMMBB..5
6 ..BBMMBBMMBBMMMM6
7 MM..MMMM........7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
##b.clear_moves()
##b.mark_moves(WHITE)
b.clear_moves()
b.make_move((0, 3), WHITE)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB......WWBB1
2 ......BBWWWWWW..2
3 ......WWWWWWWW..3
4 WWWWWWWWWWWWWW..4
5 ....BBBBBB..BB..5
6 ..BB..BB..BB....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
def __init__(self, visualize=False):
self.visualize = visualize
self.board = Board(params.shape, params.size, params.openCells)
if visualize:
self.viz = Visualizer(self.board)
