def test_game_cycle(game):
game.make_turn(Vector([0, 0]))
game.make_turn(Vector([2, 2]))
game.make_turn(Vector([0, 1]))
game.make_turn(Vector([2, 1]))
game.make_turn(Vector([0, 2]))
assert game.winner == Color.black
def test_put_stone(board):
board.put_stone(Vector([0, 0]), Color.white)
board.put_stone(Vector([1, 1]), Color.white)
board.put_stone(Vector([2, 2]), Color.white)
assert board.map[0][0] == Color.white\
and board.map[1][1] == Color.white \
and board.map[2][2] == Color.white
def game_on_board(self, players, with_foul):
self.game = Game(game_params.board_width, game_params.board_height,
game_params.length_to_win, players, with_foul)
game_params.PLAYER_COUNT = len(self.game.players)
if self.game_client is not None:
self.game_client.message_monitor.game = self.game
self.display.blit(view_params.board_back, (0, 0))
pygame.time.wait(200)
click_handler = ClickHandler()
cycle = True
self.clock.tick(20)
while cycle:
for event in pygame.event.get():
if event.type == pygame.QUIT:
cycle = False
if self.game_client is not None:
self.game_client.close_event()
if self.game_server is not None:
pygame.time.wait(100)
self.game_server.close()
self.game_server = None
pygame.quit()
click_pos = pygame.mouse.get_pos()
click = pygame.mouse.get_pressed()
current_player = self.game.current_player
if current_player.entity == const.PlayerEntity.human:
if click_handler.check_click(click_pos, click):
if click_handler.handle() is not None:
x, y = click_handler.handle()
if self.game_client is not None:
if current_player.color.value \
== self.game_client.message_monitor.id:
message = {
RequestParams.TYPE: RequestType.MOVE,
RequestParams.ID:
current_player.color.value,
RequestParams.MOVE: (x, y)
}
if self.game.board[Vector([x, y])] \
== const.Color.non:
self.game_client.send_message(message)
self.game.make_turn(Vector([x, y]))
else:
self.game.make_turn(Vector([x, y]))
else:
continue
else:
x, y = current_player.make_move(self.game)
self.game.make_turn(Vector([x, y]))
if pygame.key.get_pressed()[pygame.K_z]:
self.game.undo_turn()
pygame.time.wait(150)
self.clear()
if self.game.winner is not None:
pygame.time.wait(150)
cycle = False
self.scoreboard.update_stat(self.game)
self.end_game()
self.update_map()
pygame.display.update()
def test_undo_moves(players, expected):
game = g.Game(5, 5, 3, players)
game.make_turn(Vector([0, 0]))
game.make_turn(Vector([0, 1]))
game.make_turn(Vector([0, 2]))
game.undo_turn()
assert game.current_player.color == expected
assert game.board[0, 2] == Color.non
def test_find_line(board, c1, c2, c3, expected):
board.put_stone(Vector(c1), Color.black)
board.put_stone(Vector(c2), Color.black)
board.put_stone(Vector(c3), Color.black)
for direct in directions:
length = board.find_line(Vector(c3), direct, Color.black, 1)
if length == expected:
assert length == expected
def make_move(self, game):
if not game.smart_bot:
x = random.randint(0, game.board.width - 1)
y = random.randint(0, game.board.height - 1)
vec = Vector([x, y])
while game.board[vec] != Color.non:
x = random.randint(0, game.board.width - 1)
y = random.randint(0, game.board.height - 1)
vec = Vector([x, y])
return x, y
def test_check_fouls_forks(two_human_players):
game = g.Game(5, 5, 5, two_human_players, True)
game.make_turn(Vector([3, 1]))
game.make_turn(Vector([0, 0]))
game.make_turn(Vector([3, 2]))
game.make_turn(Vector([0, 1]))
game.make_turn(Vector([1, 3]))
game.make_turn(Vector([1, 0]))
game.make_turn(Vector([2, 3]))
game.make_turn(Vector([1, 1]))
game.make_turn(Vector([3, 3]))
assert game.board[Vector([3, 3])] == Color.non
def make_move(self, game):
weights_table = {}
for x in range(game.board.width):
for y in range(game.board.height):
vector = Vector([x, y])
if game.board[vector] != Color.non:
continue
weights_table[vector] = count_weight(game, vector)
values = list(weights_table.values())
keys = list(weights_table.keys())
return keys[values.index(max(values))]
def run(self):
while True:
self.request = pickle.loads(self.server_socket.recv(1024))
if self.request[RequestParams.TYPE] == RequestType.CURRENT_PLAYERS:
self.player_params = self.request[RequestParams.PLAYERS]
player_id = self.request[RequestParams.ID].value - 1
player = self.request[RequestParams.PLAYERS][player_id]
if self.id is None:
self.id = player[RequestParams.ID].value
self.max_players = self.request[RequestParams.MAX_PLAYERS]
elif self.request[RequestParams.TYPE] == RequestType.BEGIN:
self.start_button.is_pressed = True
elif self.request[RequestParams.TYPE] == RequestType.MOVE:
place = self.request[RequestParams.MOVE]
self.game.make_turn(Vector([place[0], place[1]]))
elif self.request[RequestParams.TYPE] == RequestType.RESTART:
self.restart_button.is_pressed = True
def test_prepare_map(board):
board[Vector([0, 0])] = 1
board[Vector([1, 1])] = 2
board.map = board.prepare_map()
assert board.map[0][0] == Color.non and board.map[1][1] == Color.non
assert len(board.map[0]) == 5
from enum import Enum
from renjuu.game.vector import Vector
directions = [Vector([1, 0]), Vector([0, 1]),
Vector([1, -1]), Vector([1, 1])]
class GameMode(Enum):
with_bot = 0
with_human = 1
class PlayerEntity(Enum):
human = 0
bot = 1
class Color(Enum):
non = 0
black = 1
white = 2
red = 3
blue = 4
yellow = 5
green = 6
pink = 7
gray = 8
def __lt__(self, other):
return self.value < other.value
def test_check_winner(game, c1, c2, c3, expected):
game.board.put_stone(Vector(c1), Color.black)
game.board.put_stone(Vector(c2), Color.black)
game.board.put_stone(Vector(c3), Color.black)
game.check_winner(Vector(c3), Color.black)
assert game.winner == Color.black
def test_check_draw(two_human_players):
game = g.Game(3, 3, 4, two_human_players)
for i in range(game.board.width):
for j in range(game.board.height):
game.make_turn(Vector([i, j]))
assert game.winner == Color.non
def test_check_fouls_long(two_human_players):
game = g.Game(10, 10, 5, two_human_players, True)
game.make_turn(Vector([1, 3]))
game.make_turn(Vector([0, 0]))
game.make_turn(Vector([2, 3]))
game.make_turn(Vector([0, 1]))
game.make_turn(Vector([3, 3]))
game.make_turn(Vector([1, 0]))
game.make_turn(Vector([5, 3]))
game.make_turn(Vector([1, 1]))
game.make_turn(Vector([6, 3]))
game.make_turn(Vector([9, 9]))
game.make_turn(Vector([4, 3]))
assert game.board[Vector([4, 3])] == Color.non
def test_game_cycle_with_bot(bot_and_human_players):
game = g.Game(5, 5, 3, bot_and_human_players)
game.make_turn(Vector([0, 0]))
game.make_turn(Vector(game.current_player.make_move(game)))
if game.board.map[0][1] == Color.non:
game.make_turn(Vector([0, 1]))
else:
game.make_turn(Vector([1, 0]))
game.make_turn(Vector(game.current_player.make_move(game)))
if game.board.map[2][0] == Color.non:
game.make_turn(Vector([2, 0]))
else:
game.make_turn(Vector([1, 1]))
game.make_turn(Vector(game.current_player.make_move(game)))
if game.board.map[2][2] == Color.non:
game.make_turn(Vector([2, 2]))
else:
game.make_turn(Vector([2, 1]))
game.make_turn(Vector(game.current_player.make_move(game)))
if game.board.map[0][2] == Color.non:
game.make_turn(Vector([0, 2]))
elif game.board.map[1][0] == Color.non:
game.make_turn(Vector([1, 0]))
game.make_turn(Vector(game.current_player.make_move(game)))
if game.board.map[2][0] == Color.non:
game.make_turn(Vector([2, 0]))
elif game.board.map[1][1] == Color.non:
game.make_turn(Vector([1, 1]))
game.make_turn(Vector(game.current_player.make_move(game)))
if game.board.map[1][2] == Color.non:
game.make_turn(Vector([1, 2]))
elif game.board.map[2][1] == Color.non:
game.make_turn(Vector([2, 1]))
elif game.board.map[2][2] == Color.non:
game.make_turn(Vector([2, 2]))
else:
assert game.winner == Color.white
return
else:
assert game.winner == Color.white
return
else:
game.make_turn(Vector([1, 1]))
game.make_turn(Vector(game.current_player.make_move(game)))
if game.board.map[2][2] == Color.non:
game.make_turn(Vector([2, 2]))
else:
game.make_turn(Vector([1, 2]))
assert game.winner == Color.black
def test_vector_not_equals(c1, c2):
v1 = Vector(c1)
v2 = Vector(c2)
assert v1 != v2
v2 = Vector(c2)
assert v1 == v2
@pytest.mark.parametrize("c1, c2", [([1, 1], [2, 2]),
([1, 1], [1, 2]),
([1, 1], [2, 1]),
([2, 1], [2, 2])])
def test_vector_not_equals(c1, c2):
v1 = Vector(c1)
v2 = Vector(c2)
assert v1 != v2
@pytest.mark.parametrize("c1, c2, expected",
[([1, 1], [2, 2], Vector([3, 3])),
([1, 1], [1, 2], Vector([2, 3])),
([1, 1], [2, 1], Vector([3, 2])),
([2, 1], [2, 2], Vector([4, 3]))])
def test_add_vector(c1, c2, expected):
v1 = Vector(c1)
v2 = Vector(c2)
assert v1 + v2 == expected
@pytest.mark.parametrize("c1, c2, expected",
[([1, 1], [2, 2], Vector([-1, -1])),
([1, 1], [1, 2], Vector([0, -1])),
([1, 1], [2, 1], Vector([-1, 0])),
([2, 1], [2, 2], Vector([0, -1]))])
def test_sub_vector(c1, c2, expected):
def test_add_vector(c1, c2, expected):
v1 = Vector(c1)
v2 = Vector(c2)
assert v1 + v2 == expected
def test_create_vector():
v1 = Vector([0, 0])
assert v1.x == 0
assert v1.y == 0
def test_block_try_block_forks(game, human, bot, moves, expected):
for move in moves:
game.board.put_stone(Vector(move), human.color)
game.switch_players()
game.make_turn(bot.make_move(game))
assert game.board[Vector(expected)] == Color.white
def test_block_line_with_4(game, bot, moves, expected):
for move in moves:
game.make_turn(Vector(move))
game.make_turn(bot.make_move(game))
assert game.board[Vector(expected)] == Color.white
def test_sub_vector(c1, c2, expected):
v1 = Vector(c1)
v2 = Vector(c2)
assert v1 - v2 == expected