def setUp(self):
self.board = Board()
self.validate = Validate()
self.board_helper = BoardHelper(self.board.all_ships)
self.human_board = Board()
self.ui = TerminalUi()
self.ai = Ai(self.validate)
def get(self, board_string):
try:
print('\n\n')
self.board = Board(board_string)
self.graphic = Graphic(self.board)
self.estimation = Estimation(self.board)
self.act = Act.none
self.get_me()
self.logic()
self.act_logic()
self.act = self.me.act_analyzer(self.act, self.next_point,
self.board)
self.direction = self.point_to_direction(self.next_point)
self.me.move(self.direction, self.board)
self.die_check()
self.graphic.global_text = self.me.str()
self.graphic.save()
command = self.create_answer()
print(f'Sending Command {command}')
return command
except Exception as e:
print(e)
return 'STOP'
def setUp(self):
self.ui = TerminalUi()
self.board = Board()
self.board_helper = BoardHelper(self.board.all_ships)
self.missed_marker = consts.MISS_MARKER
self.hit_marker = consts.HIT_MARKER
self.sunk_marker = consts.SUNK_MARKER
def testBoardInitialisation(self):
board = Board(50, 50)
self.assertTrue(len(board.grid) == 50)
for lig in range(50):
self.assertTrue(len(board.grid[lig]) == 50)
for col in range(50):
cell = board.grid[lig][col]
self.assertTrue(isinstance(cell, Cell))
def testBoardGetCell(self):
board = Board(50, 50)
for lig in range(50):
for col in range(50):
cell = board.get_cell(lig, col)
self.assertTrue(isinstance(cell, Cell))
self.assertTrue(cell.lig == lig)
self.assertTrue(cell.col == col)
def testBoardGetGrid(self):
board = Board(50, 50)
board_grid = board.get_grid()
self.assertTrue(len(board.grid[0]) == len(board_grid[0]))
self.assertTrue(len(board.grid) == len(board_grid))
for lig in range(50):
for col in range(50):
self.assertTrue(board.grid[lig][col] == board_grid[lig][col])
def testBoardInitialisation(self):
board = Board(50, 50)
self.assertTrue(len(board.grid) == 50)
for lig in range(50):
self.assertTrue(len(board.grid[lig]) == 50)
for col in range(50):
cell = board.grid[lig][col]
self.assertListEqual(cell, [])
def __init__(self, player_names: list):
self.board = Board()
self.players = self.__generate_players(player_names)
self.round = 1
self.draw_pile = [
TraitCard(name=f'Trait{i}')
for i in range(self.__total_trait_cards)
] # Todo: Replace self.draw_pile with real traits.
self.phase = Phase.DEAL
def testDisplay(self):
board = Board(20, 20)
expected_display = "- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n"
self.assertEqual(board.display(), expected_display)
w = Wizard("Plop")
board.move(w, 0, 0)
expected_display = "X - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n"
self.assertEqual(board.display(), expected_display)
board.move(w, 2, 4)
expected_display = "- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - X - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n- - - - - - - - - - - - - - - - - - - - \n"
self.assertEqual(board.display(), expected_display)
def testBoardDisplayerDecorator(self):
board = Board(50, 50)
player = Player(50, 1)
self.assertTrue(issubclass(BoardDisplayer, Board))
decorated_board = BoardDisplayer(board, player)
self.assertTrue(board.get_grid() == decorated_board.get_grid())
self.assertTrue(board.get_height() == decorated_board.get_height())
self.assertTrue(board.get_width() == decorated_board.get_width())
self.assertTrue(hasattr(decorated_board, "display"))
self.assertTrue(inspect.ismethod(decorated_board.display))
self.assertTrue(hasattr(decorated_board, "wait_move"))
self.assertTrue(inspect.ismethod(decorated_board.wait_move))
def create_game(self, adversary_id, board_size, target):
try:
if self.online:
self.game_id = con.create_game(my_team, adversary_id,
board_size, target)
else:
self.game_id = 0
self.m = target
self.n = board_size
self.team2 = adversary_id
self.game_ready = True
self.board = Board(self.m, self.n)
return True
except Exception as e:
print('Exception: ', e)
print('Failed to join the game')
return False
def __init__(self, players=None):
if players is None:
players = {
'White': {
'name': 'Anon',
'ELO': None
},
'Black': {
'name': 'Anon',
'ELO': None
}
}
else:
self.players = players
self.board = Board()
self.board.setup()
def join_game(self, game_id, adversary_id, board_size, target):
self.m = target
self.n = board_size
self.game_id = game_id
self.team2 = adversary_id
if self.online:
board_map, status = con.get_board_map(self.game_id)
else:
status = 'OK'
if status == 'OK':
self.game_ready = True
self.board = Board(self.m, self.n)
if self.online:
self.board.read_board_string(board_map)
return True
else:
print('Failed to join the game')
return False
def testCharacterMove(self):
board = Board(50, 50)
w = Wizard("Plop")
self.assertEqual(w.x, None)
self.assertEqual(w.y, None)
board.move(w, 0, 0)
self.assertEqual(w.x, 0)
self.assertEqual(w.y, 0)
cell = board.grid[0][0]
self.assertTrue(w in cell)
cell_before_move = board.grid[w.x][w.y]
board.move(w, 2, 4)
self.assertEqual(w.x, 2)
self.assertEqual(w.y, 4)
cell = board.grid[2][4]
self.assertTrue(w not in cell_before_move)
self.assertTrue(w in cell)
def status(self):
# rows
for i in range(constants.BOARD_SIZE):
if self.board[i][0] != constants.EMPTY and self.board[i][1] != constants.EMPTY\
and self.board[i][2] != constants.EMPTY and self.board[i][0] == self.board[i][1]\
and self.board[i][1] == self.board[i][2]:
return self.board[i][0]
# cols
transposed = Board()
for i in range(constants.BOARD_SIZE):
for j in range(constants.BOARD_SIZE):
transposed.board[i][j] = self.board[j][i]
for i in range(constants.BOARD_SIZE):
if transposed.board[i][0] != constants.EMPTY and transposed.board[i][1] != constants.EMPTY\
and transposed.board[i][2] != constants.EMPTY and transposed.board[i][0] == transposed.board[i][1]\
and transposed.board[i][1] == transposed.board[i][2]:
return transposed.board[i][0]
# prim diag
if self.board[0][0] != constants.EMPTY and self.board[1][1] != constants.EMPTY\
and self.board[2][2] != constants.EMPTY and self.board[0][0] == self.board[1][1]\
and self.board[1][1] == self.board[2][2]:
return self.board[0][0]
# secondary diag
if self.board[0][2] != constants.EMPTY and self.board[1][1] != constants.EMPTY\
and self.board[2][0] != constants.EMPTY and self.board[0][2] == self.board[1][1]\
and self.board[2][0] == self.board[1][1]:
return self.board[0][2]
# draw
if self.full():
return constants.DRAW
# in progress
return constants.IN_PROGRESS
def ai_test():
b = Board(5, 15)
ai = Ai()
# b.move(7, 7, 2)
# print(b.get_board())
while True:
x, y = str.split(input('Enter move position (left up is 0 0): \"x y\"\n'), ' ')
x = int(x)
y = int(y)
b.move(x, y, 1)
if b.get_result() != 0:
print(b.get_board())
print(b.get_result())
break
# print(b.get_board())
x, y = ai.move(b, 2)
b.move(x, y, 2)
if b.get_result() != 0:
print(b.get_board())
print(b.get_result())
break
print(b.get_board())
print(x, y)
def __init__(self, ):
self.board = Board()
self.players = [Player('0'), Player('1')]
self.turn = 0
self.songs = {
1: 'Birth',
2: 'Death',
3: 'Resistance',
4: 'Reign',
5: 'Ascent',
6: 'Tirany',
7: 'the Mysteries'
}
self.buildings = {
'Birth': ['Garden', 'House'],
'Death': [],
'Resistance': ['Thorn wall', 'Barracks'],
'Reign': ['Bridge'],
'Ascent': ['Harbor', 'Library', 'Statue'],
'Tirany': ['Prison', 'Rebel camp'],
'the Mysteries': ['Shrine']
}
self.setupFigures()
self.loosers = None
def setUp(self):
self.board = Board()
def setUp(self):
self.terrains = {"my_terrain_0": (1, 1), "my_terrain_1": (2, 2)}
self.board = Board(self.terrains)
def setUp(self):
self.board = Board()
self.score = Score(self.board.table)
#!/usr/bin/env python
# -- coding: UTF-8 --
from core.board import Board, Cell
from core.character import *
from core.display import *
board = Board(20, 20)
player = Player(50, 1)
boardDisplayer = ConsoleBoard(board, player)
# while True:
# boardDisplayer.display()
# new_cell = boardDisplayer.wait_move()
# player.move(new_cell)
boardDisplayer.display()
def game_singleplayer(player1, player2):
def graphics(surface, delta_t, player1, player2, entities):
surface.fill((255, 255, 255))
timer = render_text(
'%.2d:%.2d' %
(delta_t.total_seconds() // 60, delta_t.total_seconds() % 60))
surface.blit(timer, ((config['WIDTH'] - timer.get_width()) // 2, 50))
if current_player == player1:
surface.blit(player1.active_name_rendered, (25, 10))
surface.blit(player2.name_rendered,
((config['WIDTH'] -
player2.name_rendered.get_width() - 25), 10))
elif current_player == player2:
surface.blit(player1.name_rendered, (25, 10))
surface.blit(player2.active_name_rendered,
((config['WIDTH'] -
player2.name_rendered.get_width() - 25), 10))
player1_points = render_text(f'{player1.points}')
surface.blit(player1_points,
((25 + player1.icon_rendered.get_width() + 25), 50 +
(player1.icon_rendered.get_height() -
player1_points.get_height()) // 2))
surface.blit(player1.icon_rendered, (25, 50))
surface.blit(
player2.icon_rendered,
((config['WIDTH'] - player2.icon_rendered.get_width() - 25), 50))
player2_points = render_text(f'{player2.points}')
surface.blit(player2_points,
(((config['WIDTH'] - player2.icon_rendered.get_width()) -
player2_points.get_width() - 50), 50 +
(player2.icon_rendered.get_height() -
player2_points.get_height()) // 2))
for entity in entities:
entity.render(surface)
global display, clock, config
board = Board((config['WIDTH'] - 600) // 2, 200, 600, 600)
pause_button = ImageButton(270, 25, 'pause.png')
resume_button = ImageButton(305, 25, 'resume.png')
start_time = datetime.datetime.now()
player1.update()
player2.update()
current_player = player1
run = True
pause = False
while run:
clock.tick(config['FPS'])
delta_t = datetime.datetime.now() - start_time
for event in pygame.event.get():
if event.type == pygame.QUIT:
quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
run = False
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
mouse_pos = pygame.mouse.get_pos()
board.is_clicked(mouse_pos, current_player)
if pause_button.is_clicked(mouse_pos):
pause = True
if resume_button.is_clicked(mouse_pos):
pause = False
if current_player.move_finished:
current_player.move_finished = False
if board.check_win_condition(current_player):
return_option = game_over(current_player)
player1.reset()
player2.reset()
if return_option == 'restart':
current_player = player1
board.reset_figures()
elif return_option == 'quit':
return
elif current_player == player1:
current_player = player2
elif current_player == player2:
current_player = player1
graphics(display, delta_t, player1, player2,
[board, pause_button, resume_button])
pygame.display.update()
return
import argparse from utility.args_game_config import ArgsGameConfig from core.connect_four_game import ConnectFourGame from core.board import Board from core.registered_player import RegisteredPlayer from views.zelle_graphics_game_view import ZelleGraphicsGameView from core.best_of_game import BestOfGame from core.strategy_loader import StrategyLoader config = ArgsGameConfig(argparse.ArgumentParser()) game = BestOfGame(ConnectFourGame(Board(7, 6)), config.number_of_games()) view = ZelleGraphicsGameView(delay=config.turn_delay()) strategies = StrategyLoader(strategies_dir="strategies") game.play(RegisteredPlayer(strategies), RegisteredPlayer(strategies), view)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import arm.arm_controler as ac
import arm.servo_controler as sc
import threading
from core.board import Board
from arm.chess_machine import ChessMachine
from assist.assistant import Assist
if __name__ == '__main__':
arm = ac.arm()
board = Board()
machine = ChessMachine(board, arm, assist=True)
machine.human_vs_human()
def main():
creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
creator.create("Individual", list, fitness=creator.FitnessMax)
toolbox = base.Toolbox()
parser = argparse.ArgumentParser()
parser.add_argument('-conf',
type=str,
required=True,
help='Definition file')
parser.add_argument('-hints',
type=str,
required=False,
default=None,
help='Hint file')
args = parser.parse_args()
puzzle_def = PuzzleDefinition()
puzzle_def.load(args.conf, args.hints)
board = Board(puzzle_def)
toolbox.register("corners_perm", random.sample, range(4), 4)
toolbox.register("edges_perm", random.sample, range(len(puzzle_def.edges)),
len(puzzle_def.edges))
toolbox.register("inner_perm", random.sample, range(len(puzzle_def.inner)),
len(puzzle_def.inner))
toolbox.register(
"individual",
tools.initCycle,
creator.Individual,
(toolbox.corners_perm, toolbox.edges_perm, toolbox.inner_perm),
n=1)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
def custom_mate(ind1, ind2):
i = random.randint(1, 3)
if i == 1:
corners = tools.cxPartialyMatched(ind1[0], ind2[0])
elif i == 2:
edges = tools.cxPartialyMatched(ind1[1], ind2[1])
elif i == 3:
inners = tools.cxPartialyMatched(ind1[2], ind2[2])
return ind1, ind2
toolbox.register("mate", custom_mate)
def custom_mutate(ind, indpb):
i = random.randint(1, 3)
if i == 1:
tools.mutShuffleIndexes(ind[0], indpb)
elif i == 2:
tools.mutShuffleIndexes(ind[1], indpb)
elif i == 3:
tools.mutShuffleIndexes(ind[2], indpb)
return ind,
toolbox.register("mutate", custom_mutate, indpb=0.1)
toolbox.register("select", tools.selTournament, tournsize=3)
def evaluate(individual):
corners_perm = individual[0]
edges_perm = individual[1]
inner_perm = individual[2]
idx = 0
for i, j in board.enumerate_corners():
board.board[i][j] = PieceRef(puzzle_def.corners[corners_perm[idx]],
0, i, j)
idx += 1
idx = 0
for i, j in board.enumerate_edges():
board.board[i][j] = PieceRef(puzzle_def.edges[edges_perm[idx]], 0,
i, j)
idx += 1
idx = 0
for i, j in board.enumerate_inner():
board.board[i][j] = PieceRef(puzzle_def.inner[inner_perm[idx]], 0,
i, j)
idx += 1
board.fix_orientation()
board.heuristic_orientation()
return board.evaluate(),
toolbox.register("evaluate", evaluate)
NGEN = 40
pop = toolbox.population(n=200)
# Evaluate the entire population
hof = tools.HallOfFame(1)
ui = BoardUi(board)
ui.init()
gen = 0
while True:
offspring = algorithms.varAnd(pop, toolbox, cxpb=0.5, mutpb=0.1)
fits = toolbox.map(toolbox.evaluate, offspring)
for fit, ind in zip(fits, offspring):
ind.fitness.values = fit
hof.update(pop)
pop = toolbox.select(offspring, k=len(pop))
# draw best
score = evaluate(hof[0])
pygame.display.set_caption(f'Puzzle (#{gen}, score {score[0]})')
ui.update()
for event in pygame.event.get():
if event.type == pygame.locals.QUIT:
pygame.quit()
sys.exit()
pygame.display.update()
gen += 1
top10 = tools.selBest(pop, k=10)
def setUp(self):
self.board = Board()
self.board_helper = BoardHelper(self.board.all_ships)
from core.connect_four_game import ConnectFourGame
from core.board import Board
from core.registered_player import RegisteredPlayer
from views.zelle_graphics_game_view import ZelleGraphicsGameView
from core.strategy_loader import StrategyLoader
from views.tracked_player import TrackedPlayer
from views.array_access_view import ArrayAccessView
from strategies.stdin_strategy import StdInStrategy
from core.player import Player
game = ConnectFourGame(Board(7, 6))
view = ZelleGraphicsGameView(delay=0.25)
strategies = StrategyLoader(strategies_dir="strategies")
bot = TrackedPlayer(RegisteredPlayer(strategies, name="Bot"),
ArrayAccessView())
player = Player("Player", StdInStrategy())
game.play(player, bot, view)
def __generate_afterstates__(self, board):
""" returns a list of Board instances, one for each valid move. The player is always Black in this representation. """
return [(Board(board.get_representation(self.color)).apply_move(
valid_move, config.BLACK), valid_move)
for valid_move in board.get_valid_moves(self.color)]
def testBoardGetDimension(self):
board = Board(24, 42)
self.assertTrue(board.get_height() == 24)
self.assertTrue(board.get_width() == 42)
def __init__(self):
self.board = Board()
self.p1 = self.select_player()
self.p2 = HumanPlayer(self.board, Piece.WHITE, first=False)
self.current_player = self.p1
self.print_board()
