def test_run_game_1(self):
board = Board(2, 5, {}, num_of_fish_per_tile=2)
player1 = Player(1)
player2 = Player(2)
player_seq = [player1, player2]
referee = Referee(player_seq, test_board=board)
assert referee.run_game() == {
'won': [player1],
'lost': [player2],
'cheated/failed': []
}
def test_referee_complete_game(self):
test_player_1 = Player()
test_player_2 = Player()
ex_referee = Referee([test_player_1, test_player_2],4,4)
ex_referee.start_game()
#check that the state in the referee is an state of a game that has ended
self.assertEqual("End", ex_referee.get_game_info()[3].phase)
#check no player has been kicked (assumes our player successfully sends valid moves/placements which is checked in test_player)
self.assertEqual([], ex_referee.get_game_info()[2])
def test_game_info_2(self):
test_player_1 = Player()
test_player_2 = Player()
test_obs = AccumulatingObserver()
ex_referee = Referee([test_player_1, test_player_2],4,4)
ex_referee.add_observer(test_obs)
ex_referee.setup_game()
self.assertEqual(ex_referee.get_game_info()[0],"In Progress")
def __init__(self):
self.welcome_text = lmgr.GLOBAL_LANGUAGE.Global.welcome_text
self.help_ps = 'help'
self.__each_score = 10
self.__referee = Referee()
self.__players = [ComputerPlayer(), HumanPlayer()]
self.__global_socre = 0
self.__global_save = None
def test_check():
# Set of moves to get us to check fast
white_moves = ['e2e3', 'f1b5']
black_moves = ['d7d6']
white = QueuePlayer(white_moves)
black = QueuePlayer(black_moves)
r = Referee(white, black)
r.play_game()
print('All we were looking for was the " - check"')
def raw_eval(board):
if str(board) in terminal_board_dict:
return terminal_board_dict[str(board)]
player_a = Player()
player_b = Player()
ref = Referee()
result = ref.playgame(player_a,
player_b,
board=board,
lookup=terminal_board_dict)
# print(len(terminal_board_dict))
return result
def administrate(player1_wrap, player2_wrap, player1_name, player2_name):
player1_wrap.reset_for_new_game()
player2_wrap.reset_for_new_game()
# give players to ref and ask it to play a game
print("starting game between ", player1_name, "and ", player2_name)
ref = Referee(player1_wrap, player2_wrap, player1_name, player2_name)
REF_WRAP = Ref_Wrapper(ref)
winner, illegal = REF_WRAP.play_game()
print("Winner: ", [winner[0]])
return winner, illegal
def test_init_success2(self):
# Tests successful 2-player init
referee = Referee(5, 10, [self.__p1, self.__p2])
# Make sure all player got assigned colors
for player in referee.players:
self.assertIn(player.color, self.__legal_colors)
self.__legal_colors.remove(player.color)
self.assertEqual(referee.cheating_players, [])
self.assertEqual(referee.failing_players, [])
self.assertFalse(referee.started)
def test_run_placement_phase(self):
test_player_1 = Player()
test_player_2 = Player()
ex_referee = Referee([test_player_1, test_player_2],4,4)
ex_referee.setup_game()
#check to make sure now in placement phase
ex_referee.run_placement_phase()
#Check to make sure penguin_map has been populated, meaning penguins have been placed
ex_map = ex_referee.state.penguin_map
for player_penguin_map in ex_map:
self.assertEqual(len(ex_map[player_penguin_map]), 4)
def __init__(self, first_player_first_move: bool, debug: bool = True):
self.board = Board()
self.referee = Referee()
self.bot = Bot(self.board.config)
self.first_player_first_move = first_player_first_move
self.bot_alias = {
"alex": self.bot.alex_bot,
"tei": self.bot.tei_bot,
"tei_v2" : self.bot.tei_bot_v2,
"jw": self.bot.alex_bot
}
self.winner = "no one"
self.debug = debug
def ai_check_win(board, coord, color, depth):
"""
Check if the move made the AI win.
"""
coord_x = coord[0]
coord_y = coord[1]
ref = Referee()
if ref.check5(board, coord, color):
board[coord_y][coord_x] = None
if not depth:
return True
return False
return False
def load_p_vs_ai(screen):
"""
Load the gamemode against an AI.
"""
run = True
board = init_board()
player_color = set_color_player()
if player_color is None:
return True
ref = Referee()
Referee.played = 0
ai_turn = True if player_color == 'w' else False
while run:
display_board(screen, board)
if ai_turn:
Referee.played += 2
if board == init_board():
pos = [9, 9]
else:
pos = ai.ai_play(board, ('b' if player_color == 'w' else 'w'))
rboard, score, msg = ref.set_stone(
board, ('b' if player_color == 'w' else 'w'), pos)
if rboard is not None:
board = rboard
win = ref.check5(board, pos, ('b'
if player_color == 'w' else 'w'))
ai_turn = False
run = ref.display_score(score, ('b'
if player_color == 'w' else 'w'),
win, msg)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
run = False
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1 and not ai_turn:
coord_x, coord_y = pygame.mouse.get_pos()
coord_x = int((coord_x - 5) / 40)
coord_y = int((coord_y - 5) / 40)
rboard, score, msg = ref.set_stone(board, player_color,
[coord_y, coord_x])
if rboard is not None:
board = rboard
win = ref.check5(board, [coord_y, coord_x], player_color)
ai_turn = True
run = ref.display_score(score, player_color, win, msg)
display_board(screen, board)
update_stone_player(screen, player_color)
pygame.display.update()
return True
def test_end_game_info(self):
test_player_1 = Player()
test_player_2 = Player()
test_obs = AccumulatingObserver()
ex_referee = Referee([test_player_1, test_player_2],4,4)
ex_referee.add_observer(test_obs)
ex_referee.setup_game()
ex_referee.run_placement_phase()
ex_referee.run_move_phase()
ex_referee.end_game()
self.assertEqual(ex_referee.get_game_info()[0],"End")
def game_test(player1, player2):
ref = Referee([player1, player2])
scores = ref.play_game()
print("GAME RESULTS: ", scores)
# game_test(HeuristicPlayer(), HeuristicPlayer())
# game_test(IterativeDeepeningPlayer(), IterativeDeepeningPlayer())
# game_test(MinimaxPlayer(), MinimaxPlayer())
# game_test(GreedyPlayer(), GreedyPlayer())
# game_test(RandomPlayer(), RandomPlayer())
# game_test(ExpectimaxPlayer(), ExpectimaxPlayer())
# game_test(AlphaBetaPlayer(), AlphaBetaPlayer())
# board_game_test()
# board_test()
def main():
# Parse the text input into a list of JSON elements.
txt = sys.stdin.read().rstrip()
json_elements = txt2json(txt)
rf = Referee()
results = []
res_print = []
for i, json_element in enumerate(json_elements):
# If the move is a pass
if i == 0:
results.append(rf.register_black_player(json_element))
# print(rf.register_black_player(json_element))
continue
elif i == 1:
results.append(rf.register_white_player(json_element))
# print(rf.register_white_player(json_element))
continue
elif i == 2:
res = copy.deepcopy(rf.board_history)
results.append(res)
# print("[")
# for b in res:
# print(b)
# print("]")
# print()
if rf.is_game_ended:
break
else:
if json_element == PASS:
play_or_pass = PASS
else:
play_or_pass = Point.from_str(json_element)
res = copy.deepcopy(rf.play_point(play_or_pass))
if isinstance(res[0], Board):
results.append(res)
# print("[")
# for b in res:
# print(b)
# print("]")
# print()
else:
results.append(res)
# print(res)
if rf.is_game_ended == False:
results.pop()
print(jsonpickle.encode(results, unpicklable=False))
def cup(self, players):
rounds = math.log(len(players), 2)
scoreboard = []
for r in range(int(rounds)):
winners = []
for i in range(len(players) / 2):
p1 = players[i * 2]
p2 = players[i * 2 + 1]
ref = Referee(p1, p2)
winner = ref.run_game()
cheated = len(winner) == 2
winner = winner[0]
if ref.color_to_name['blue'] == winner:
winners.append(p1)
if cheated:
scoreboard.append(
(float("inf"), ref.color_to_name['white']))
else:
scoreboard.append(
(rounds - r + 1, ref.color_to_name['white']))
else:
winners.append(p2)
if cheated:
scoreboard.append(
(float("inf"), ref.color_to_name['blue']))
else:
scoreboard.append(
(rounds - r + 1, ref.color_to_name['blue']))
if r == int(rounds) - 1:
scoreboard.append((1.0, winner))
players = winners
list.sort(scoreboard)
rank = 0
buffer = 1
last_v = 0
print "Rank Player"
for v, k in scoreboard:
if v != last_v:
rank = rank + buffer
buffer = 1
else:
buffer = buffer + 1
last_v = v
print rank, k
def __make_round_games(self):
"""
Makes a round by creating games (Referee objects) with players.
:return: resulting list of Referee (representing games) and list of list of IPlayer as returned by
__divide_players()
"""
divide: [[IPlayer]] = self.__divide_players()
games: [Referee] = []
# For each list of players (game), make up a referee
for player_list in divide:
referee: Referee = Referee(self.__board_row_no, self.__board_col_no, player_list, Manager.FISH_NUMBER)
# referee.subscribe_final_game_report(blah)
games.append(referee)
return games, divide
def main(HOST, PORT):
'''
:param HOST: server host
:param PORT: server port
:return: open server socket, listen 3-5 clients' connection and run the game until the game over
'''
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
soc.bind((HOST, PORT))
soc.listen()
players = {}
count = 0
# start connection and wait for client to connect
while True:
(client_connection, client_address) = soc.accept()
p = Proxy(client_connection, client_address)
players[client_connection] = p
count += 1
if count >= 3:
# This is required function to wait for 30 seoncds for any newly joined client
# but is too slow so changed to 3 seconds now for final code walk. Can be easily
# changed to 30 seconds by just changing the settimout parameter from 3 to 30
# wait for 3 seconds
soc.settimeout(3)
while True:
try:
(client_connection, client_address) = soc.accept()
p = Proxy(client_connection, client_address)
players[client_connection] = p
count += 1
if count == 5:
break
except:
break
break
# play game
ref = Referee(list(players.values()))
winners, losers = ref.run()
winners_name, losers_name, log = get_names(winners, losers, ref)
log_entries(log)
soc.close()
def ai_analyse(board, coord_x, coord_y):
"""
Calcul the possibility
"""
color = board[coord_y][coord_x]
estimation = 0
estimation += ai_vertical_analyse(board, coord_x, coord_y, color)
estimation += ai_horizontal_analyse(board, coord_x, coord_y, color)
estimation += ai_diagonal1_analyse(board, coord_x, coord_y, color)
estimation += ai_diagonal2_analyse(board, coord_x, coord_y, color)
estimation += ai_check3_analyse(board, [coord_y, coord_x], color)
estimation += ai_check4_analyse(board, [coord_y, coord_x], color)
ref = Referee()
estimation += ai_capture_analyse(board, [coord_y, coord_x], color)
chck, text = ref.is_double3(board, [coord_y, coord_x], color)
_ = text
if chck:
estimation = 0
return estimation
def test_setup_game(self):
test_player_1 = Player()
test_player_2 = Player()
ex_referee = Referee([test_player_1, test_player_2],4,4)
ex_referee.setup_game()
self.assertEqual(ex_referee.state.board.columns,4)
self.assertEqual(ex_referee.state.board.rows,4)
# count that there are at least than 8 non-zero squares - places to put the penguins
counter = 0
for row in range(len(ex_referee.state.board.tiles)):
for column in range(len(ex_referee.state.board.tiles[0])):
if ex_referee.state.board.tiles[row][column] != 0:
counter += 1
self.assertGreaterEqual(counter, 8)
def test_start_success3(self):
# Tests a game in which a player cheats by making an illegal action (moving in place)
referee = Referee(3, 4, [self.__p6, self.__cheating_player3])
# Make up observer callback to validate game report
def game_report_observer(report: dict):
self.assertEqual(report['cheating_players'],
[self.__cheating_player3])
self.assertEqual(report['failing_players'], [])
self.assertEqual(report['leaderboard'], [{
'name': 'Roger Dodger',
'color': Color.RED,
'score': 12
}])
referee.subscribe_final_game_report(game_report_observer)
referee.start()
self.assertEqual(referee.winners, [self.__p6])
self.assertCountEqual(referee.losers, [self.__cheating_player3])
def test_end_game(self):
test_player_1 = Player()
test_player_2 = Player()
test_obs = AccumulatingObserver()
ex_referee = Referee([test_player_1, test_player_2],4,4)
ex_referee.add_observer(test_obs)
ex_referee.setup_game()
ex_referee.run_placement_phase()
self.assertEqual(test_obs.messages_rec[-1][0],"Placement")
ex_referee.run_move_phase()
self.assertEqual(test_obs.messages_rec[-1][0],"Move")
ex_referee.end_game()
#test that the observer's received an end message
self.assertEqual(test_obs.messages_rec[-1][0],"End")
#list of kicked players is empty
self.assertEqual(test_obs.messages_rec[-1][2],[])
def ai_check4_analyse(board, coord, color):
"""
Check if 4 allies stones are aligned.
"""
estimation = 0
ref = Referee()
for case in ref.case:
dir_yx = [coord[0] - 4 * case[0], coord[1] - 4 * case[1]]
cpt = 0
for i in range(0, 9):
calculated_x = dir_yx[1] + i * case[1]
calculated_y = dir_yx[0] + i * case[0]
if not ((calculated_x > 18 or calculated_x < 0) or
(calculated_y > 18 or calculated_y < 0)):
if board[calculated_y][calculated_x] == color:
cpt += 1
if cpt == 4:
estimation += 500 * Referee.played
else:
cpt = 0
return estimation
def run(self, players: list):
next_round_players = []
if len(players) == 1:
self.results['winner'] = [players[0]]
return
for p in range(0, len(players), 2):
game = Referee(players[p], players[p + 1]).get_results()
print(game)
winner, loser = 0, 1
if game[0][1] == game[1][1]:
coin_flip = random.randint(0, 1)
winner = coin_flip
loser = 0 if winner else 1
next_round_players.append(game[winner][0])
loser_player_name = game[loser][0]
if self.round in self.results:
self.results[self.round].append(loser_player_name)
else:
self.results[self.round] = [loser_player_name]
self.round += 1
self.run(next_round_players)
def ai_check3_analyse(board, coord, color):
"""
Check if 3 enemy stones are aligned.
"""
enemy = 'b' if color == 'w' else 'w'
estimation = 0
ref = Referee()
for case in ref.case:
dir_yx = [coord[0] - 3 * case[0], coord[1] - 3 * case[1]]
cpt = 0
for i in range(0, 7):
calculated_x = dir_yx[1] + i * case[1]
calculated_y = dir_yx[0] + i * case[0]
if not ((calculated_x > 18 or calculated_x < 0) or
(calculated_y > 18 or calculated_y < 0)):
if board[calculated_y][calculated_x] == enemy:
cpt += 1
if cpt == 3:
estimation += 1000 * Referee.played
else:
cpt = 0
return estimation
def test_run_move_phase(self):
test_player_1 = Player()
test_player_2 = Player()
ex_referee = Referee([test_player_1, test_player_2],4,4)
ex_referee.setup_game()
#check to make sure now in placement phase
ex_referee.run_placement_phase()
# Check scores to make sure they are all 0 before moving
ex_score_map = ex_referee.state.score_map
for player_score_map in ex_score_map:
self.assertEqual(ex_score_map[player_score_map],0)
# Run moving phase, check if scores are not 0
# for a 4x4 board with no holes, both players will have made at least one move
ex_referee.run_move_phase()
for player_score_map in ex_score_map:
self.assertNotEqual(ex_score_map[player_score_map],0)
def start_game():
"""
Create new players, and play a single game
"""
# TODO rudimentary, but works for now
turn_time = timedelta(seconds=10)
if '1s' in sys.argv:
turn_time = timedelta(seconds=1)
elif '30m' in sys.argv:
turn_time = timedelta(minutes=30)
white = StockfishPlayer(turn_time=turn_time)
if 'email' in sys.argv:
black = EmailPlayer()
elif 'fishes' in sys.argv:
black = StockfishPlayer(turn_time=turn_time)
else:
black = TerminalPlayer()
print(f'Starting game with {white} vs {black} - ({turn_time} per turn)')
r = Referee(white, black)
r.play_game()
screen = Screen()
screen.setup(width=1200, height=800)
screen.bgcolor("black")
screen.title("Hamsik2rang's Pong")
screen.tracer(0)
screen.listen()
draw_line()
collider = Collider()
player = Player(collider)
ball = Ball(collider=collider)
enemy = Enemy(collider=collider, ball=ball)
referee = Referee(player=player, enemy=enemy, ball=ball)
screen.update()
collider.set_player(player)
collider.set_enemy(enemy)
collider.set_ball(ball)
ball.set_referee(referee=referee)
screen.onkeypress(key="Up", fun=player.move_up)
screen.onkeypress(key="Down", fun=player.move_down)
# write game logic below
while referee.game_is_on:
screen.update()
time.sleep(FRAME)
def create_referee(self, name):
return Referee(self.__next_id(), name)
board = Board()
moves_5 = [(1, 2), (0, 0), (1, 0), (1, 1), (2, 0), (2, 2)]
for move in moves_2:
board.enter_move(move)
assert board.is_final(), "board should be terminal for o"
board = Board()
moves_6 = [(1, 2), (0, 2), (1, 0), (1, 1), (0, 1), (2, 0)]
for move in moves_3:
board.enter_move(move)
assert board.is_final(), "board should be terminal for o"
n_games = 100
player_a = Player()
player_b = MCTSPlayer()
ref = Referee()
o_results = []
print("begin to play!")
for i in range(n_games):
if i % 10 == 0:
print("\n")
print(Counter(o_results))
player_a.reseed(i)
player_b.reseed(i)
result = ref.playgame(player_a, player_b, should_print=False)
o_results.append(result)
# print(result, end=' ')
print(Counter(o_results))
x_results = []
