async def test_unfreeze_players():
game = Game()
game.alive_players = [Player(0, 128, 128), Player(1, 128, 128)]
logic = TickLogicPart(game)
await logic.unfreeze_players()
assert not game.alive_players[0].is_freeze
assert not game.alive_players[1].is_freeze
def test_messages_get_tick_game_data():
game = Game()
game.time_left = 42
game.npcs = [object(), object()]
assert messages.get_tick_game_data(game) == dict(
status='game',
action='info',
ticks_left=42,
npcs_left=2,
)
async def test_do_actions_after_10_ticks():
game = Game()
logic = TickLogicPart(game)
game.ticks = 10
with patch.multiple(logic,
unfreeze_players=DEFAULT,
do_it_after_ticks=DEFAULT) as patch_values:
await logic.do_it()
assert not patch_values['unfreeze_players'].called
patch_values['do_it_after_ticks'].assert_called_once_with()
def test_messages_get_over_game_data():
player_a = Player(x=1, y=2, player_id=0)
player_b = Player(x=1, y=2, player_id=1)
player_a.score = 20
player_b.score = 40
game = Game()
game.alive_players = [player_a, player_b]
assert messages.get_over_game_data(game) == dict(
status='game',
action='over',
winner=player_b.id.hex,
)
def test_render_bullets(pygame):
game = Game()
game.bullets = [
Bullet(32, 32),
Bullet(64, 32),
]
drawer = Drawer(game)
drawer._blit = Mock(spec=drawer._blit)
drawer._render_bullets()
assert drawer._blit.call_args_list == [
call('BULLET', game.bullets[0]),
call('BULLET', game.bullets[1]),
]
def test_render_npcs(pygame):
game = Game()
game.npcs = [
NPC(32, 32),
NPC(64, 32),
]
drawer = Drawer(game)
drawer._blit = Mock(spec=drawer._blit)
drawer._render_npcs()
assert drawer._blit.call_args_list == [
call('IMG_NPC_1', game.npcs[0]),
call('IMG_NPC_1', game.npcs[1]),
]
def test_render_players_with_freeze(pygame):
game = Game()
game.alive_players = [
Player(0, 32, 32),
]
game.alive_players[0].set_freeze()
drawer = Drawer(game)
drawer._blit = Mock(spec=drawer._blit)
drawer._render_players()
assert drawer._blit.call_args_list == [
call('IMG_PLAYER_1_1', game.alive_players[0]),
call('FREEZE', game.alive_players[0]),
]
def test_render_players(pygame):
game = Game()
game.alive_players = [
Player(0, 32, 32),
Player(1, 64, 32),
]
drawer = Drawer(game)
drawer._blit = Mock(spec=drawer._blit)
drawer._render_players()
assert drawer._blit.call_args_list == [
call('IMG_PLAYER_1_1', game.alive_players[0]),
call('IMG_PLAYER_2_1', game.alive_players[1]),
]
def test_get_info_label_from_freezed(pygame):
drawer = Drawer(Game())
player = Player(0, 0, 0)
player.set_connection(object())
player.set_freeze()
assert drawer._get_info_label(player) == 'FREEZE'
async def test_do_it_after_ticks():
game = Game()
game.time_left = 250
logic = TickLogicPart(game)
with patch.multiple(logic,
unset_player_actions=DEFAULT,
send_info=DEFAULT,
do_sth_with_npcs=DEFAULT) as patch_values:
await logic.do_it_after_ticks()
patch_values['unset_player_actions'].assert_called_once_with()
patch_values['do_sth_with_npcs'].assert_called_once_with()
patch_values['send_info'].assert_called_once_with()
assert game.time_left == 249
def test_render_background(pygame):
game = Game()
drawer = Drawer(game)
drawer.background = Mock(spec=Surface)
drawer._render_background()
drawer.screen.blit.assert_called_once_with(drawer.background, (0, 0))
def test_drawer_blit_simple(pygame):
drawer = Drawer(Game())
image = object()
drawer.IMAGES = {'IMAGE': image}
drawer._blit('IMAGE', NPC(1, 2))
drawer.screen.blit.assert_called_once_with(
image, (drawer.OFFSET + 1, drawer.OFFSET + 2))
async def test_move():
game = Game()
# default direction is UP
game.bullets = [Bullet(128, 128)]
game.alive_players = [Player(x=128, y=128, player_id=0)]
# but default direction of NPC is DOWN
game.npcs = [NPC(128, 128)]
game.alive_players[0].set_speed(2)
game.npcs[0].set_speed(2)
await MoveLogicPart(game).do_it()
assert game.alive_players[0].get_position() == {'x': 128, 'y': 128 - 2}
assert game.npcs[0].get_position() == {'x': 128, 'y': 128 + 2}
assert game.bullets[0].get_position() == {'x': 128, 'y': 128 - 8}
def test_drawer_blit_pack(pygame):
drawer = Drawer(Game())
image = object()
drawer.IMAGES = {'IMAGE': {Direction.DOWN: image}}
monster = NPC(1, 2)
monster.set_direction(Direction.DOWN)
drawer._blit('IMAGE', monster)
drawer.screen.blit.assert_called_once_with(
image, (drawer.OFFSET + 1, drawer.OFFSET + 2))
def test_render_label(pygame):
drawer = Drawer(Game())
drawer.font.render = Mock(return_value='IMAGE')
drawer._render_label(id='test',
label='test',
cords=(1, 2),
color=(0, 1, 2))
drawer.screen.blit.assert_called_once_with(
'IMAGE', (drawer.OFFSET_LABELS_X + 1, drawer.OFFSET_LABELS_Y + 2))
drawer.font.render.assert_called_once_with('test', 1, (0, 1, 2))
def run():
args = parser.parse_args()
game = Game(
turn_off_after_end=args.turn_off_after_end,
max_players=args.max_players,
show_borders=args.show_collision_border,
)
game.load_map(args.map)
if not args.hidden_window:
game.set_drawer()
loop = get_event_loop()
coro_server = start_server(
handle_connection(game), args.ip, args.port,
loop=loop,
)
server = loop.run_until_complete(coro_server)
loop.run_until_complete(game_loop(game, 33 / args.speed / 1000))
try:
loop.run_forever()
except EOFError:
pass
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
async def test_send_info(messages):
game = Game()
logic = TickLogicPart(game)
with patch.object(game, 'broadcast') as broadcast_mock:
await logic.send_info()
broadcast_mock.assert_called_once_with(
messages.get_tick_game_data.return_value)
messages.get_tick_game_data.assert_called_once_with(game)
# todo - check single spawn bullet with directions
def test_render_solid_color(pygame):
game = Game()
surface = Mock(spec=Surface)
drawer = Drawer(game)
drawer._render_solid_colors(surface)
surface.fill.assert_called_once_with((0x5f, 0x57, 0x4f))
pygame.draw.rect.assert_called_once_with(surface, (0, 0, 0), (
drawer.OFFSET,
drawer.OFFSET,
drawer.game.WIDTH,
drawer.game.HEIGHT,
))
def test_render_walls(pygame):
game = Game()
game.walls = [
TinyWall(48, 32),
Metal(64, 48),
Water(96, 32),
]
surface = Mock(spec=Surface)
drawer = Drawer(game)
os = Drawer.OFFSET
drawer.WALLS = { # pygame surface can't use eq operator ;_;
TinyWall: 'tiny_wall',
Metal: 'metal',
Water: 'water',
}
drawer._render_walls(surface)
assert surface.blit.call_args_list == [
call('tiny_wall', (os + 48, os + 32), (16, 0, 8, 8)),
call('metal', (os + 64, os + 48), (0, 16, 32, 32)),
call('water', (os + 96, os + 32), (0, 0, 32, 32)),
]
def test_messages_get_world_data():
game = Game()
player = Player(x=1, y=1, player_id=0)
game.alive_players = [player]
game.npcs = [NPC(2, 2)]
game.bullets = [Bullet(3, 3)]
game.walls = [TinyWall(x=4, y=4), Water(x=5, y=5)]
game.coins = [Coin(x=4, y=4), Coin(x=5, y=5)]
assert messages.get_world_data(player, game) == dict(
id=player.id.hex,
cords=[
dict(type='player', id=player.id.hex, position={
'x': 1,
'y': 1
}),
dict(type='npc', id=game.npcs[0].id.hex, position={
'x': 2,
'y': 2
}),
dict(type='bullet',
id=game.bullets[0].id.hex,
position={
'x': 3,
'y': 3
}),
dict(type='tinywall',
id=game.walls[0].id.hex,
position={
'x': 4,
'y': 4
}),
dict(type='water',
id=game.walls[1].id.hex,
position={
'x': 5,
'y': 5
}),
dict(type='coin',
id=game.coins[0].id.hex,
position={
'x': 4,
'y': 4
}),
dict(type='coin',
id=game.coins[1].id.hex,
position={
'x': 5,
'y': 5
}),
])
async def test_set_old_position():
game = Game()
game.bullets = [Bullet(128, 128)]
game.alive_players = [Player(x=128, y=128, player_id=0)]
game.npcs = [NPC(128, 128)]
for monster in game.get_monsters_chain():
monster.set_position(42, 24)
await SetOldPositionLogicPart(game).do_it()
for monster in game.bullets + game.alive_players + game.npcs:
assert monster.old_position.x == 42
assert monster.old_position.y == 24
def test_render_text(pygame):
game = Game()
game.npcs = [NPC(0, 0), NPC(1, 1)]
game.players = [Player(0, 32, 32), Player(1, 64, 32)]
game.players[0].set_nick('1234')
game.players[0].score = 100
game.time_left = 125
game.npcs_left = 3
drawer = Drawer(game)
drawer._render_label = Mock(spec=drawer._render_label)
drawer._render_text()
assert drawer._render_label.call_args_list == [
call('title', 'BATTLE CITY AI', (0, 00)),
call('npc_left', 'NPCs left: 003', (0, 40)),
call('npc', 'NPCs in area: 002', (0, 80)),
call('time', 'Time left: 125', (0, 120)),
call('not-ready', 'NOT READY', (0, 180)),
call('p-1', '1234 000100', (0, 240), drawer.PLAYER_COLORS[0]),
call('p-info-1', 'WAIT', (0, 260), drawer.PLAYER_COLORS[0]),
call('p-2', 'P1 000000', (0, 280), drawer.PLAYER_COLORS[1]),
call('p-info-2', 'WAIT', (0, 300), drawer.PLAYER_COLORS[1]),
]
async def game_loop(game: Game, speed: float=0.033):
while True:
await wait([
game.step(),
sleep(speed),
])
def make_game(*players):
game = Game()
game.alive_players = players
return game
def test_get_info_label_from_killed_player(pygame):
drawer = Drawer(Game())
player = Player(0, 0, 0)
player.set_game_over()
assert drawer._get_info_label(player) == 'KILLED'
def test_get_info_label_from_not_connected_player(pygame):
drawer = Drawer(Game())
player = Player(0, 0, 0)
assert drawer._get_info_label(player) == 'WAIT'
def test_get_info_label_from_connected_player(pygame):
drawer = Drawer(Game())
player = Player(0, 0, 0)
player.set_connection(object())
assert drawer._get_info_label(player) == ''
