def test_has_ended(self):
player1 = Player()
player2 = Player()
game = Checkers(player1, player2)
for cell in game.board.cells:
cell.value = None
self.assertTrue(game.has_ended())
def test_possible_movements(self):
player1 = Player()
player2 = Player()
game = Checkers(player1, player2)
for cell in game.board.cells:
cell.value = None
game.board.set_cell(2, 3, "X")
game.board.set_cell(2, 5, "O")
game.board.set_cell(4, 3, "x")
game.board.set_cell(4, 5, "o")
game.player_in_turn = 0
self.assertEqual(6, len(game.possible_movements()))
game.player_in_turn = 1
self.assertEqual(6, len(game.possible_movements()))
game.board.set_cell(3, 4, "x")
game.board.set_cell(2, 3, "o")
game.board.set_cell(2, 5, "o")
game.board.set_cell(4, 3, "o")
game.board.set_cell(4, 5, "o")
game.player_in_turn = 0
self.assertEqual(2, len(game.possible_movements()))
game.board.set_cell(3, 4, "X")
self.assertEqual(4, len(game.possible_movements()))
game.board.set_cell(3, 4, "o")
game.board.set_cell(2, 3, "x")
game.board.set_cell(2, 5, "x")
game.board.set_cell(4, 3, "x")
game.board.set_cell(4, 5, "x")
game.player_in_turn = 1
self.assertEqual(2, len(game.possible_movements()))
game.board.set_cell(3, 4, "O")
self.assertEqual(4, len(game.possible_movements()))
def test_recieve_input(self):
player = AIPlayer()
game = Checkers(player, Player())
options = game.possible_movements()
action = player.recieve_input(options)
self.assertGreaterEqual(action, 0)
self.assertLessEqual(action, len(options))
def __init__(self, **props):
self.model = Checkers()
self._root = props['root']
self.parent = props['parent']
self.training = props['training'] # If true, game will be played
# against an evolved GPController
statusbar = Label(self._root,
relief=SUNKEN,
font=('Helvetica', 7),
anchor=NW)
statusbar.pack(side='bottom', fill='x')
self.view = BoardView(self._root,
model=self.model,
parent=self,
statusbar=statusbar,
invisible=True)
if self.training:
self.view.override_canvas(TrainingCanvas())
self.fitness = props['fitness']
self.player_color = BLACK
self.num_players = 1
self.set_controllers()
self._controller1.start_turn()
self.filename = None
def test_play(self, input):
player = CheckersPlayer()
game = Checkers(player, CheckersPlayer())
game.player_in_turn = 0
self.assertTrue(game.board.get_cell(5, 0).value == "x")
player.play()
self.assertTrue(game.board.get_cell(4, 1).value == "x")
self.assertTrue(game.board.get_cell(5, 0).value is None)
def test_evaluate_winner(self):
player1 = Player()
player2 = Player()
game = Checkers(player1, player2)
game.player_in_turn = 0
for cell in game.board.cells:
if cell.value in ["o", "0"]:
cell.value = None
self.assertEqual(player1, game.evaluate_winner())
game.player_in_turn = 1
for cell in game.board.cells:
if cell.value in ["x", "X"]:
cell.value = None
self.assertEqual(player2, game.evaluate_winner())
def new_game(self):
self._stop_updates()
self._save_curr_game_if_needed()
self.filename = None
self._root.title('Raven ' + VERSION)
self.model = Checkers()
self.player_color = BLACK
self.view.reset_view(self.model)
self.think_time = self.parent.thinkTime.get()
self.set_controllers()
self.view.update_statusbar()
self.view.reset_toolbar_buttons()
self.view.curr_annotation = ''
self.controller1.start_turn()
def __init__(self):
self._model = Checkers()
self.to_move = None
self.moves = []
self.description = ''
self.black_men = []
self.white_men = []
self.black_kings = []
self.white_kings = []
self.flip_board = False
self.num_players = 1
self._move_check = False
self._bm_check = False
self._bk_check = False
self._wm_check = False
self._wk_check = False
def __init__(self, **props):
self.model = Checkers()
self._root = props['root']
self.parent = props['parent']
statusbar = Label(self._root,
relief=SUNKEN,
font=('Helvetica', 7),
anchor=NW)
statusbar.pack(side='bottom', fill='x')
self.view = BoardView(self._root,
model=self.model,
parent=self,
statusbar=statusbar)
self.player_color = BLACK
self.num_players = 1
self.set_controllers()
self.controller1.start_turn()
self.filename = None
self.think_time = self.parent.thinkTime.get()
def test_get_movement(self):
player1 = Player()
player2 = Player()
game = Checkers(player1, player2)
for cell in game.board.cells:
cell.value = None
game.board.set_cell(7, 4, "x")
game.board.set_cell(6, 3, "o")
game.board.set_cell(4, 3, "o")
game.board.set_cell(2, 3, "o")
game.board.set_cell(0, 3, "o")
game.board.set_cell(6, 5, "o")
game.board.set_cell(4, 5, "o")
game.board.set_cell(2, 5, "o")
game.board.set_cell(0, 5, "o")
movements = list(game._get_movement(7, 4, ["LU", "RU"], ["o", "O"]))
self.assertEqual([((1, 2), [(2, 3), (4, 3), (6, 3)]),
((1, 6), [(2, 5), (4, 3), (6, 3)]),
((1, 2), [(2, 3), (4, 5), (6, 5)]),
((1, 6), [(2, 5), (4, 5), (6, 5)])], movements)
game.board.set_cell(7, 4, None)
game.board.set_cell(5, 6, "X")
game.board.set_cell(6, 1, "o")
game.board.set_cell(4, 1, "o")
game.board.set_cell(2, 1, "o")
game.board.set_cell(0, 1, "o")
game.board.set_cell(6, 7, "o")
game.board.set_cell(4, 7, "o")
game.board.set_cell(2, 7, "o")
game.board.set_cell(0, 7, "o")
movements = list(
game._get_movement(5, 6, ["LU", "RU", "LD", "RD"], ["o", "O"]))
self.assertEqual([((1, 6), [(2, 5), (4, 3), (4, 1), (2, 1), (2, 3),
(4, 5)]),
((7, 0), [(6, 1), (4, 1), (2, 1), (2, 3), (4, 5)]),
((5, 6), [(6, 5), (6, 3), (4, 1), (2, 1), (2, 3),
(4, 5)]), ((1, 6), [(2, 5), (4, 5)]),
((7, 4), [(6, 5)])], movements)
def setUpClass(self):
print("Starting up...")
self.db = CFDatabase(config.getCfDbFile())
self.checkers = Checkers()
self.checkerList = ['deadcode.DeadStores']
self.checkerIndex = 0
return fixUnusedParam(code, bugData)
if bugData.getChecker() == 'clang-diagnostic-constant-conversion':
return fixConstConv(code, bugData)
return None
ccdb = CCDatabase(config.getCcDbFile())
db = sqlite3.connect('../Results/db.sqlite')
cursor = db.cursor()
cursor.execute('SELECT * FROM bugs')
dataFromDb = cursor.fetchall()
bugs = []
bugsPerFile = {}
BUG_NOT_PROCESSED = 0
vcs = GitProvider(config.getRepoDir())
checkers = Checkers()
currentCommit = vcs.getAllVersions(config.getBranch())[0]
bugDataList = {}
fileContents = {}
codechecker = CodeChecker(config.getRepoDir())
if len(dataFromDb) > 0:
print("Skipping steps 1-2, DB already filled with data")
for bug in dataFromDb:
if bug[2] not in bugsPerFile:
bugsPerFile[bug[2]] = []
if bug[3] == BUG_NOT_PROCESSED:
bugDataList[bug[0]] = ccdb.getNotResolvedBugData(bug[0])
bugsPerFile[bug[2]].append(bug[0])
else:
# 1.
epsilon=args.epsilon,
batch_size=args.batch_size,
action_space=action_space,
input_dims=[8 * 8 + 1],
lr=args.lr,
eps_dec=args.epsilon_decay),
'white':
Agent(gamma=args.gamma,
epsilon=args.epsilon,
batch_size=args.batch_size,
action_space=action_space,
input_dims=[8 * 8 + 1],
lr=args.lr,
eps_dec=args.epsilon_decay)
}
env = Checkers()
initial_state = env.save_state()
eps_history = []
score = {'black': 0, 'white': 0}
os.makedirs(args.checkpoints_dir, exist_ok=True)
for i in range(args.games):
print(
f"episode={i}, score={score}, black_eps:{players['black'].epsilon}, white_eps:{players['white'].epsilon}"
)
score = {'black': 0, 'white': 0}
env.restore_state(initial_state)
winner = None
moves = torch.tensor(env.legal_moves())
board, turn, last_moved_piece = env.save_state()
def __init__(self):
self.ccdb = CCDatabase(config.getCcDbFile())
self.codeChecker = CodeChecker(config.getRepoDir())
self.code = []
self.checkers = Checkers()
def __init__(self):
self.db = CFDatabase(config.getCfDbFile())
self.lexer = CxxLexer()
self.checkers = Checkers()
def test_recieve_input(self, input):
player = HumanPlayer()
game = Checkers(player, Player())
self.assertEqual(player.recieve_input(game.possible_movements()), 4)
sleep(1)
screen.fill(BLACK)
# print winner
score = game.scoreGame()
font = pygame.font.SysFont('Calibri', 30, True, False)
text = ""
# tie
if score == 0:
text = font.render("TIE", True, WHITE)
# ai wins
elif score == 1:
text = font.render("You lose, AI wins", True, WHITE)
# human wins
else:
text = font.render("You win, AI loses", True, WHITE)
screen.blit(text, [width / 3 + width / 12, height / 2])
# update screen
pygame.display.flip()
sleep(1.5)
# end game
pygame.quit()
print('Starting Checkers game...')
game = Checkers()
agent = Minimax(game, 3, False)
print('Program terminated')
from checkers import Checkers, AIPlayer, HumanPlayer
if __name__ == '__main__':
checkers = Checkers(AIPlayer(), AIPlayer())
checkers.start()
print("Game ended in {} turns".format(checkers.turn + 1))
checkers.render()
if checkers.winner:
print("Winner!! Player {}".format(checkers.player_in_turn + 1))
else:
print("Draw!!")
def __init__(self):
self.vcs = GitProvider(config.getRepoDir())
self.ccdb = CCDatabase(config.getCcDbFile())
self.codeChecker = CodeChecker(config.getRepoDir())
self.checkers = Checkers()
self.loadCommitList()
def __init__(self, history=[]):
# Rollout statistics
self.child_visits = []
# Terminal values for the first player
# 1 for win
# 0 for draw
# -1 for loss
# None for incomplete
self.game_value = None
# XXX Conventions:
# - Black player moves first
# - Ego-centric views assume the king row are at the top, i.e. starts at the bottom (Second player has the same view as absolute)
self.ch = Checkers()
# Action space
self.actions = []
# Simple moves
for from_sq in range(self.ch.n_positions):
for to_sq in self.ch.neighbors[from_sq]:
if to_sq is not None:
simple_move = (from_sq, to_sq)
self.actions.append(simple_move)
assert 98 == len(self.actions), 'There should be 98 simple moves.'
# Jumps
for from_sq in range(self.ch.n_positions):
row, col = self.ch.sq2pos(from_sq)
# For each direction
for di, (drow, dcol) in enumerate(Checkers.dir2del):
next_row, next_col = row + 2 * drow, col + 2 * dcol
if 0 <= next_row < self.ch.size and 0 <= next_col < self.ch.size:
# Within bound
to_sq = self.ch.pos2sq(next_row, next_col)
jump = (from_sq, to_sq)
self.actions.append(jump)
self.num_actions = len(self.actions)
assert 98 + 72 == self.num_actions, 'There should be 98 simple moves and 72 jumps.'
# Inverse dictionary
self.action2ind = {
action: ind
for ind, action in enumerate(self.actions)
}
# Square mapping from absolute to first player's ego-centric (reflect through the center)
self.abs2ego_sq = {}
for sq in range(self.ch.n_positions):
row, col = self.ch.sq2pos(sq)
re_row, re_col = -row + self.ch.size - 1, -col + self.ch.size - 1
re_sq = self.ch.pos2sq(re_row, re_col)
self.abs2ego_sq[sq] = re_sq
# Inverse
self.ego2abs_sq = {re_sq: sq for sq, re_sq in self.abs2ego_sq.items()}
# Move mapping from absolute to first player's ego-centric
self.abs2ego_ac = {}
for ac, (from_sq, to_sq) in enumerate(self.actions):
ego_move = (self.abs2ego_sq[from_sq], self.abs2ego_sq[to_sq])
ego_ac = self.action2ind[ego_move]
self.abs2ego_ac[ac] = ego_ac
# Inverse
self.ego2abs_ac = {
ego_ac: ac
for ac, ego_ac in self.abs2ego_ac.items()
}
# Fast forward to the last state by taking actions from history
self.history = []
for action in history:
self.apply(action)
