def test_ok(self):
state = GameState()
state.add_robot((9, 9), 0)
self.assertTrue(state.is_valid_action((9, 9), ['guard']))
self.assertTrue(state.is_valid_action((9, 9), ['suicide']))
self.assertTrue(state.is_valid_action((9, 9), ['attack', (9, 10)]))
self.assertTrue(state.is_valid_action((9, 9), ['move', (9, 10)]))
def test_add_robot(self):
state = GameState()
state.add_robot((9, 9), 0, robot_id=7, hp=42)
self.assertTrue((9, 9) in state.robots)
self.assertEqual(state.robots[(9, 9)].player_id, 0)
self.assertEqual(state.robots[(9, 9)].robot_id, 7)
self.assertEqual(state.robots[(9, 9)].hp, 42)
def test_try_move_in_circle(self):
state = GameState()
state.add_robot((8, 8), 0)
state.add_robot((9, 8), 1)
state.add_robot((9, 9), 0)
state.add_robot((8, 9), 1)
actions = {
(8, 8): ['move', (9, 8)],
(9, 8): ['move', (9, 9)],
(9, 9): ['move', (8, 9)],
(8, 9): ['move', (8, 8)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 8)))
self.assertEqual(state2.robots[9, 8].hp, settings.robot_hp)
self.assertEqual(state2.robots[9, 8].player_id, 0)
self.assertTrue(state2.is_robot((9, 9)))
self.assertEqual(state2.robots[9, 9].hp, settings.robot_hp)
self.assertEqual(state2.robots[9, 9].player_id, 1)
self.assertTrue(state2.is_robot((8, 9)))
self.assertEqual(state2.robots[8, 9].hp, settings.robot_hp)
self.assertEqual(state2.robots[8, 9].player_id, 0)
self.assertTrue(state2.is_robot((8, 8)))
self.assertEqual(state2.robots[8, 8].hp, settings.robot_hp)
self.assertEqual(state2.robots[8, 8].player_id, 1)
def test_try_move_in_circle(self):
state = GameState(settings)
state.add_robot((8, 8), 0)
state.add_robot((9, 8), 1)
state.add_robot((9, 9), 0)
state.add_robot((8, 9), 1)
actions = {
(8, 8): ['move', (9, 8)],
(9, 8): ['move', (9, 9)],
(9, 9): ['move', (8, 9)],
(8, 9): ['move', (8, 8)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 8)))
self.assertEqual(state2.robots[9, 8].hp, settings.robot_hp)
self.assertEqual(state2.robots[9, 8].player_id, 0)
self.assertTrue(state2.is_robot((9, 9)))
self.assertEqual(state2.robots[9, 9].hp, settings.robot_hp)
self.assertEqual(state2.robots[9, 9].player_id, 1)
self.assertTrue(state2.is_robot((8, 9)))
self.assertEqual(state2.robots[8, 9].hp, settings.robot_hp)
self.assertEqual(state2.robots[8, 9].player_id, 0)
self.assertTrue(state2.is_robot((8, 8)))
self.assertEqual(state2.robots[8, 8].hp, settings.robot_hp)
self.assertEqual(state2.robots[8, 8].player_id, 1)
def test_three_collision(self):
state = GameState()
loc1 = (10, 11)
loc2 = (9, 10)
loc3 = (11, 10)
dest = (10, 10)
state.add_robot(loc1, 0)
state.add_robot(loc2, 1)
state.add_robot(loc3, 1)
actions = {
loc1: ['move', dest],
loc2: ['move', dest],
loc3: ['move', dest]
}
deltas = state.get_delta(actions)
d_player0 = delta_for(deltas, loc1)
d_player1_1 = delta_for(deltas, loc2)
d_player1_2 = delta_for(deltas, loc3)
self.assertEqual(d_player0.hp - d_player0.hp_end,
d_player1_1.damage_caused + d_player1_2.damage_caused)
player1_hp_lose = d_player1_1.hp - d_player1_1.hp_end + \
d_player1_2.hp - d_player1_2.hp_end
self.assertEqual(player1_hp_lose, d_player0.damage_caused)
def test_lack_of_location(self):
state = GameState()
state.add_robot((9, 9), 0)
robot = state.robots[(9, 9)]
with self.assertRaises(Exception):
Player._validate_action(robot, ['move'])
def test_add_robot(self):
state = GameState()
state.add_robot((9, 9), 0, robot_id=7, hp=42)
self.assertTrue((9, 9) in state.robots)
self.assertEquals(state.robots[(9, 9)].player_id, 0)
self.assertEquals(state.robots[(9, 9)].robot_id, 7)
self.assertEquals(state.robots[(9, 9)].hp, 42)
def test_three_collision(self):
state = GameState()
loc1 = (10, 11)
loc2 = (9, 10)
loc3 = (11, 10)
dest = (10, 10)
state.add_robot(loc1, 0)
state.add_robot(loc2, 1)
state.add_robot(loc3, 1)
actions = {
loc1: ['move', dest],
loc2: ['move', dest],
loc3: ['move', dest]
}
deltas = state.get_delta(actions)
d_player0 = delta_for(deltas, loc1)
d_player1_1 = delta_for(deltas, loc2)
d_player1_2 = delta_for(deltas, loc3)
self.assertEqual(d_player0.hp - d_player0.hp_end,
d_player1_1.damage_caused + d_player1_2.damage_caused)
player1_hp_lose = d_player1_1.hp - d_player1_1.hp_end + \
d_player1_2.hp - d_player1_2.hp_end
self.assertEqual(player1_hp_lose, d_player0.damage_caused)
def test_spawn_hop_in(self):
state = GameState()
state.add_robot((4, 4), 0)
actions = {(4, 4): ["move", (4, 3)]}
state2 = state.apply_actions(actions)
self.assertTrue(not state2.is_robot((4, 3)) or state2.robots[(4, 3)].robot_id != state.robots[4, 4].robot_id)
def test_spawn_dodge(self):
state = GameState()
state.add_robot((4, 3), 0)
actions = {(4, 3): ["move", (4, 4)]}
state2 = state.apply_actions(actions)
self.assertTrue(state2.is_robot((4, 4)))
def test_spawn_kills(self):
state = GameState()
state.add_robot((4, 3), 0)
actions = {(4, 3): ["guard"]}
state2 = state.apply_actions(actions)
self.assertTrue(not state2.is_robot((4, 3)) or state2.robots[(4, 3)].robot_id != state.robots[4, 3].robot_id)
def test_repr_too_long(self):
state = GameState()
state.add_robot((9, 9), 0)
class long_action(list):
def __repr__(self):
return 'leethaxxor' * 100
action = long_action(['guard'])
self.assertFalse(state.is_valid_action((9, 9), action))
def test_suicide_dodge(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {(10, 10): ['sucide'], (9, 10): ['move', (8, 10)]}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((8, 10)))
self.assertEqual(state2.robots[8, 10].hp, settings.robot_hp)
def test_suicide_does_no_damage_to_teammates(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 0)
actions = {(10, 10): ['guard'], (9, 10): ['suicide']}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp, settings.robot_hp)
self.assertFalse(state2.is_robot((9, 10)))
def test_spawn_dodge(self):
state = GameState()
state.add_robot((4, 3), 0)
actions = {
(4, 3): ['move', (4, 4)]
}
state2 = state.apply_actions(actions)
self.assertTrue(state2.is_robot((4, 4)))
def test_attack_hop_in(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((8, 10), 1)
actions = {(10, 10): ['attack', (9, 10)], (8, 10): ['move', (9, 10)]}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 10)))
damage = settings.robot_hp - state2.robots[9, 10].hp
self.assertTrue(
settings.attack_range[0] <= damage <= settings.attack_range[1])
def test_guarding_reduces_damage(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {(10, 10): ['guard'], (9, 10): ['suicide']}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp,
settings.robot_hp - settings.suicide_damage // 2)
self.assertFalse(state2.is_robot((9, 10)))
def test_move_into_suicide_bot(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {(10, 10): ['suicide'], (9, 10): ['move', (10, 10)]}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 10)))
self.assertEqual(
state2.robots[9, 10].hp, settings.robot_hp -
settings.collision_damage - settings.suicide_damage)
def test_move_no_collision(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((8, 10), 0)
actions = {(10, 10): ['move', (11, 10)], (8, 10): ['move', (7, 10)]}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((11, 10)))
self.assertEqual(state2.robots[11, 10].hp, settings.robot_hp)
self.assertTrue(state2.is_robot((7, 10)))
self.assertEqual(state2.robots[7, 10].hp, settings.robot_hp)
def test_guarding_reduces_damage(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {(10, 10): ['attack', (9, 10)], (9, 10): ['guard']}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 10)))
damage = settings.robot_hp - state2.robots[9, 10].hp
self.assertTrue(settings.attack_range[0] //
2 <= damage <= settings.attack_range[1] // 2)
def test_get_game_info(self):
state = GameState()
state.add_robot((9, 9), 0)
state.add_robot((6, 11), 1)
game_info = state.get_game_info(0)
self.assertEquals(game_info.robots[9, 9].location, (9, 9))
self.assertEquals(game_info.robots[9, 9].hp, state.robots[(9, 9)].hp)
self.assertEquals(game_info.robots[9, 9].player_id, state.robots[(9, 9)].player_id)
self.assertEquals(game_info.robots[9, 9].robot_id, state.robots[(9, 9)].robot_id)
self.assertEquals(game_info.robots[6, 11].location, (6, 11))
self.assertEquals(game_info.robots[6, 11].hp, state.robots[(6, 11)].hp)
self.assertEquals(game_info.robots[6, 11].player_id, state.robots[(6, 11)].player_id)
self.assertRaises(AttributeError, lambda: game_info.robots[6, 11].robot_id)
self.assertEquals(game_info.turn, state.turn)
def test_attack_kills(self):
state = GameState()
state.add_robot((10, 10), 0, hp=settings.attack_range[0])
state.add_robot((9, 10), 1, hp=settings.attack_range[0])
actions = {
(10, 10): ['attack', (9, 10)],
(9, 10): ['attack', (10, 10)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertFalse(state2.is_robot((10, 10)))
self.assertFalse(state2.is_robot((9, 10)))
def test_spawn_hop_in(self):
state = GameState()
state.add_robot((4, 4), 0)
actions = {
(4, 4): ['move', (4, 3)]
}
state2 = state.apply_actions(actions)
self.assertTrue(not state2.is_robot((4, 3)) or
state2.robots[(4, 3)].robot_id !=
state.robots[4, 4].robot_id)
def test_spawn_kills(self):
state = GameState()
state.add_robot((4, 3), 0)
actions = {
(4, 3): ['guard']
}
state2 = state.apply_actions(actions)
self.assertTrue(not state2.is_robot((4, 3)) or
state2.robots[(4, 3)].robot_id !=
state.robots[4, 3].robot_id)
def test_attack_kills(self):
state = GameState()
state.add_robot((10, 10), 0, hp=settings.attack_range[0])
state.add_robot((9, 10), 1, hp=settings.attack_range[0])
actions = {
(10, 10): ['attack', (9, 10)],
(9, 10): ['attack', (10, 10)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertFalse(state2.is_robot((10, 10)))
self.assertFalse(state2.is_robot((9, 10)))
def test_suicide_dodge(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {
(10, 10): ['sucide'],
(9, 10): ['move', (8, 10)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((8, 10)))
self.assertEqual(state2.robots[8, 10].hp, settings.robot_hp)
def test_guarding_ingnores_collisions(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {(10, 10): ['move', (9, 10)], (9, 10): ['guard']}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp,
settings.robot_hp - settings.collision_damage)
self.assertTrue(state2.is_robot((9, 10)))
self.assertEqual(state2.robots[9, 10].hp, settings.robot_hp)
def test_basic_suicide(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {(10, 10): ['attack', (9, 10)], (9, 10): ['suicide']}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp,
settings.robot_hp - settings.suicide_damage)
self.assertFalse(state2.is_robot((9, 10)))
def test_ok(self):
state = GameState()
state.add_robot((9, 9), 0)
robot = state.robots[(9, 9)]
Player._validate_action(robot, ['guard'])
Player._validate_action(robot, ['suicide'])
Player._validate_action(robot, ['guard', None])
Player._validate_action(robot, ['suicide', (1, 1)])
Player._validate_action(robot, ['attack', (9, 10)])
Player._validate_action(robot, ['move', (9, 10)])
Player._validate_action(robot, ('guard', (2, 3)))
Player._validate_action(robot, ('suicide', None))
Player._validate_action(robot, ('attack', (9, 10)))
Player._validate_action(robot, ('move', (9, 10)))
def test_suicide_does_no_damage_to_teammates(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 0)
actions = {
(10, 10): ['guard'],
(9, 10): ['suicide']
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp, settings.robot_hp)
self.assertFalse(state2.is_robot((9, 10)))
def test_guarding_reduces_damage(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {
(10, 10): ['guard'],
(9, 10): ['suicide']
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp,
settings.robot_hp - settings.suicide_damage/2)
self.assertFalse(state2.is_robot((9, 10)))
def test_guarding_reduces_damage(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {
(10, 10): ['attack', (9, 10)],
(9, 10): ['guard']
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 10)))
damage = settings.robot_hp - state2.robots[9, 10].hp
self.assertTrue(
settings.attack_range[0]/2 <= damage <= settings.attack_range[1]/2)
def test_attack_hop_in(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((8, 10), 1)
actions = {
(10, 10): ['attack', (9, 10)],
(8, 10): ['move', (9, 10)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 10)))
damage = settings.robot_hp - state2.robots[9, 10].hp
self.assertTrue(
settings.attack_range[0] <= damage <= settings.attack_range[1])
def test_spawn_dodge_overwrite(self):
state = GameState()
state.add_robot((4, 3), 0)
actions = {
(4, 3): ['move', (4, 4)]
}
# ensure that a robot will get spawned at (4, 3)
state._get_spawn_locations = lambda: [(i, 3) for i in range(10)]
state2 = state.apply_actions(actions)
self.assertTrue(state2.is_robot((4, 4)))
self.assertTrue(state2.is_robot((4, 3)))
def test_suicide(self):
state = GameState()
loc1 = (10, 11)
dest1 = (10, 10)
loc2 = (9, 10)
state.add_robot(loc1, 0)
state.add_robot(loc2, 1)
actions = {loc1: ['move', dest1], loc2: ['suicide']}
deltas = state.get_delta(actions)
d_guard = delta_for(deltas, loc1)
d_suicide = delta_for(deltas, loc2)
self.assertEqual(d_guard.hp - d_guard.hp_end, d_suicide.damage_caused)
def test_move_no_collision(self):
state = GameState(settings)
state.add_robot((10, 10), 0)
state.add_robot((8, 10), 0)
actions = {
(10, 10): ['move', (11, 10)],
(8, 10): ['move', (7, 10)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((11, 10)))
self.assertEqual(state2.robots[11, 10].hp, settings.robot_hp)
self.assertTrue(state2.is_robot((7, 10)))
self.assertEqual(state2.robots[7, 10].hp, settings.robot_hp)
def test_basic_suicide(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {
(10, 10): ['attack', (9, 10)],
(9, 10): ['suicide']
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp,
settings.robot_hp - settings.suicide_damage)
self.assertFalse(state2.is_robot((9, 10)))
def test_guarding_ingnores_collisions(self):
state = GameState(settings)
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {
(10, 10): ['move', (9, 10)],
(9, 10): ['guard']
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp,
settings.robot_hp - settings.collision_damage)
self.assertTrue(state2.is_robot((9, 10)))
self.assertEqual(state2.robots[9, 10].hp, settings.robot_hp)
def test_move_into_suicide_bot(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((9, 10), 1)
actions = {
(10, 10): ['suicide'],
(9, 10): ['move', (10, 10)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 10)))
self.assertEqual(state2.robots[9, 10].hp,
settings.robot_hp -
settings.collision_damage -
settings.suicide_damage)
def test_attack(self):
state = GameState()
loc1 = (10, 11)
dest1 = (10, 10)
loc2 = (9, 10)
dest2 = dest1
state.add_robot(loc1, 0)
state.add_robot(loc2, 1)
actions = {loc1: ['move', dest1], loc2: ['attack', dest2]}
deltas = state.get_delta(actions)
d_move = delta_for(deltas, loc1)
d_attack = delta_for(deltas, loc2)
self.assertEqual(d_move.hp - d_move.hp_end, d_attack.damage_caused)
def test_basic_collision(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((8, 10), 1)
actions = {
(10, 10): ['move', (9, 10)],
(8, 10): ['move', (9, 10)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp,
settings.robot_hp - settings.collision_damage)
self.assertTrue(state2.is_robot((8, 10)))
self.assertEqual(state2.robots[8, 10].hp,
settings.robot_hp - settings.collision_damage)
def test_get_game_info(self):
state = GameState()
state.add_robot((9, 9), 0)
state.add_robot((6, 11), 1)
game_info = state.get_game_info(0)
self.assertEqual(game_info.robots[9, 9].location, (9, 9))
self.assertEqual(game_info.robots[9, 9].hp, state.robots[(9, 9)].hp)
self.assertEqual(game_info.robots[9, 9].player_id,
state.robots[(9, 9)].player_id)
self.assertEqual(game_info.robots[9, 9].robot_id,
state.robots[(9, 9)].robot_id)
self.assertEqual(game_info.robots[6, 11].location, (6, 11))
self.assertEqual(game_info.robots[6, 11].hp, state.robots[(6, 11)].hp)
self.assertEqual(game_info.robots[6, 11].player_id,
state.robots[(6, 11)].player_id)
self.assertRaises(AttributeError,
lambda: game_info.robots[6, 11].robot_id)
self.assertEqual(game_info.turn, state.turn)
def test_simple_collision(self):
state = GameState()
loc1 = (10, 11)
dest1 = (10, 10)
loc2 = (9, 10)
dest2 = dest1
state.add_robot(loc1, 0)
state.add_robot(loc2, 1)
actions = {loc1: ['move', dest1], loc2: ['move', dest2]}
deltas = state.get_delta(actions)
d_move1 = delta_for(deltas, loc1)
d_move2 = delta_for(deltas, loc2)
self.assertEqual(d_move1.hp - d_move1.hp_end, d_move2.damage_caused)
self.assertEqual(d_move2.hp - d_move2.hp_end, d_move1.damage_caused)
def test_suicide(self):
state = GameState()
loc1 = (10, 11)
dest1 = (10, 10)
loc2 = (9, 10)
state.add_robot(loc1, 0)
state.add_robot(loc2, 1)
actions = {
loc1: ['move', dest1],
loc2: ['suicide']
}
deltas = state.get_delta(actions)
d_guard = delta_for(deltas, loc1)
d_suicide = delta_for(deltas, loc2)
self.assertEqual(d_guard.hp - d_guard.hp_end, d_suicide.damage_caused)
def test_attack(self):
state = GameState()
loc1 = (10, 11)
dest1 = (10, 10)
loc2 = (9, 10)
dest2 = dest1
state.add_robot(loc1, 0)
state.add_robot(loc2, 1)
actions = {
loc1: ['move', dest1],
loc2: ['attack', dest2]
}
deltas = state.get_delta(actions)
d_move = delta_for(deltas, loc1)
d_attack = delta_for(deltas, loc2)
self.assertEqual(d_move.hp - d_move.hp_end, d_attack.damage_caused)
def test_move_train(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((11, 10), 0)
state.add_robot((12, 10), 0)
actions = {
(10, 10): ['move', (9, 10)],
(11, 10): ['move', (10, 10)],
(12, 10): ['move', (11, 10)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 10)))
self.assertEqual(state2.robots[9, 10].hp, settings.robot_hp)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp, settings.robot_hp)
self.assertTrue(state2.is_robot((11, 10)))
self.assertEqual(state2.robots[11, 10].hp, settings.robot_hp)
def test_try_swap(self):
state = GameState()
state.add_robot((9, 9), 0)
state.add_robot((8, 9), 1)
actions = {(9, 9): ['move', (8, 9)], (8, 9): ['move', (9, 9)]}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 9)))
self.assertEqual(state2.robots[9, 9].player_id, 0)
self.assertEqual(state2.robots[9, 9].robot_id,
state.robots[9, 9].robot_id)
self.assertEqual(state2.robots[9, 9].hp,
settings.robot_hp - settings.collision_damage)
self.assertTrue(state2.is_robot((8, 9)))
self.assertEqual(state2.robots[8, 9].player_id, 1)
self.assertEqual(state2.robots[8, 9].robot_id,
state.robots[8, 9].robot_id)
self.assertEqual(state2.robots[8, 9].hp,
settings.robot_hp - settings.collision_damage)
def test_unobvious_collision(self):
state = GameState()
state.add_robot((9, 10), 0)
state.add_robot((9, 12), 1)
state.add_robot((9, 11), 0)
state.add_robot((11, 11), 1)
actions = {
(9, 10): ['move', (9, 11)],
(9, 12): ['move', (9, 11)],
(9, 11): ['move', (10, 11)],
(11, 11): ['move', (10, 11)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 10)))
self.assertEqual(state2.robots[9, 10].hp, settings.robot_hp)
self.assertTrue(state2.is_robot((9, 12)))
self.assertEqual(state2.robots[9, 12].hp,
settings.robot_hp - settings.collision_damage)
self.assertTrue(state2.is_robot((9, 11)))
self.assertEqual(state2.robots[9, 11].hp,
settings.robot_hp - settings.collision_damage * 2)
self.assertTrue(state2.is_robot((11, 11)))
self.assertEqual(state2.robots[11, 11].hp,
settings.robot_hp - settings.collision_damage)
def test_train_collision(self):
state = GameState()
state.add_robot((10, 10), 0)
state.add_robot((11, 10), 1)
state.add_robot((12, 10), 0)
state.add_robot((8, 10), 1)
actions = {
(10, 10): ['move', (9, 10)],
(11, 10): ['move', (10, 10)],
(12, 10): ['move', (11, 10)],
(8, 10): ['move', (9, 10)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((10, 10)))
self.assertEqual(state2.robots[10, 10].hp,
settings.robot_hp - settings.collision_damage * 2)
self.assertTrue(state2.is_robot((11, 10)))
self.assertEqual(state2.robots[11, 10].hp,
settings.robot_hp - settings.collision_damage * 2)
self.assertTrue(state2.is_robot((12, 10)))
self.assertEqual(state2.robots[12, 10].hp,
settings.robot_hp - settings.collision_damage)
self.assertTrue(state2.is_robot((8, 10)))
self.assertEqual(state2.robots[8, 10].hp,
settings.robot_hp - settings.collision_damage)
def test_unobvious_collision(self):
state = GameState(settings)
state.add_robot((9, 10), 0)
state.add_robot((9, 12), 1)
state.add_robot((9, 11), 0)
state.add_robot((11, 11), 1)
actions = {
(9, 10): ['move', (9, 11)],
(9, 12): ['move', (9, 11)],
(9, 11): ['move', (10, 11)],
(11, 11): ['move', (10, 11)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 10)))
self.assertEqual(state2.robots[9, 10].hp, settings.robot_hp)
self.assertTrue(state2.is_robot((9, 12)))
self.assertEqual(state2.robots[9, 12].hp,
settings.robot_hp - settings.collision_damage)
self.assertTrue(state2.is_robot((9, 11)))
self.assertEqual(state2.robots[9, 11].hp,
settings.robot_hp - settings.collision_damage*2)
self.assertTrue(state2.is_robot((11, 11)))
self.assertEqual(state2.robots[11, 11].hp,
settings.robot_hp - settings.collision_damage)
def test_collision_and_attack(self):
state = GameState()
loc1 = (10, 11)
loc2 = (9, 10)
loc3 = (11, 11)
dest = (10, 10)
attack_dest = loc1
state.add_robot(loc1, 0)
state.add_robot(loc2, 1)
state.add_robot(loc3, 1)
actions = {
loc1: ['move', dest],
loc2: ['move', dest],
loc3: ['attack', attack_dest]
}
deltas = state.get_delta(actions)
d_player0 = delta_for(deltas, loc1)
d_player1_move = delta_for(deltas, loc2)
d_player1_attack = delta_for(deltas, loc3)
self.assertEqual(d_player1_move.damage_caused,
settings.collision_damage)
self.assertTrue(settings.attack_range[0] <=
d_player1_attack.damage_caused <=
settings.attack_range[1])
self.assertEqual(d_player0.hp - d_player0.hp_end,
d_player1_move.damage_caused +
d_player1_attack.damage_caused)
player1_hp_lose = d_player1_move.hp - d_player1_move.hp_end + \
d_player1_attack.hp - d_player1_attack.hp_end
self.assertEqual(player1_hp_lose, d_player0.damage_caused)
def test_collision_and_attack(self):
state = GameState()
loc1 = (10, 11)
loc2 = (9, 10)
loc3 = (11, 11)
dest = (10, 10)
attack_dest = loc1
state.add_robot(loc1, 0)
state.add_robot(loc2, 1)
state.add_robot(loc3, 1)
actions = {
loc1: ['move', dest],
loc2: ['move', dest],
loc3: ['attack', attack_dest]
}
deltas = state.get_delta(actions)
d_player0 = delta_for(deltas, loc1)
d_player1_move = delta_for(deltas, loc2)
d_player1_attack = delta_for(deltas, loc3)
self.assertEqual(d_player1_move.damage_caused,
settings.collision_damage)
self.assertTrue(settings.attack_range[0]
<= d_player1_attack.damage_caused <=
settings.attack_range[1])
self.assertEqual(d_player0.hp - d_player0.hp_end,
d_player1_move.damage_caused +
d_player1_attack.damage_caused)
player1_hp_lose = d_player1_move.hp - d_player1_move.hp_end + \
d_player1_attack.hp - d_player1_attack.hp_end
self.assertEqual(player1_hp_lose, d_player0.damage_caused)
def test_simple_collision(self):
state = GameState()
loc1 = (10, 11)
dest1 = (10, 10)
loc2 = (9, 10)
dest2 = dest1
state.add_robot(loc1, 0)
state.add_robot(loc2, 1)
actions = {
loc1: ['move', dest1],
loc2: ['move', dest2]
}
deltas = state.get_delta(actions)
d_move1 = delta_for(deltas, loc1)
d_move2 = delta_for(deltas, loc2)
self.assertEqual(d_move1.hp - d_move1.hp_end, d_move2.damage_caused)
self.assertEqual(d_move2.hp - d_move2.hp_end, d_move1.damage_caused)
def test_try_swap(self):
state = GameState(settings)
state.add_robot((9, 9), 0)
state.add_robot((8, 9), 1)
actions = {
(9, 9): ['move', (8, 9)],
(8, 9): ['move', (9, 9)]
}
state2 = state.apply_actions(actions, spawn=False)
self.assertTrue(state2.is_robot((9, 9)))
self.assertEqual(state2.robots[9, 9].player_id, 0)
self.assertEqual(state2.robots[9, 9].robot_id,
state.robots[9, 9].robot_id)
self.assertEqual(state2.robots[9, 9].hp,
settings.robot_hp - settings.collision_damage)
self.assertTrue(state2.is_robot((8, 9)))
self.assertEqual(state2.robots[8, 9].player_id, 1)
self.assertEqual(state2.robots[8, 9].robot_id,
state.robots[8, 9].robot_id)
self.assertEqual(state2.robots[8, 9].hp,
settings.robot_hp - settings.collision_damage)
def test_scores(self):
state = GameState()
state.add_robot((9, 9), 0)
state.add_robot((6, 11), 1)
state.add_robot((8, 14), 0)
self.assertEqual(state.get_scores(), [2, 1])
class Simulator:
def __init__(self, player1_path, player2_path):
self.match_id = None
self.player = Player(player1_path) if player1_path else None
if self.player:
self.player1_path = player1_path
self.player.set_player_id(1)
self.player2 = Player(player2_path) if player2_path else None
if self.player2:
self.player2_path = player2_path
self.player2.set_player_id(0)
self.turn_repeat = False
self.UI = SimulatorUI(settings)
self.UI.setTitle("Robot Game Simulator")
self.state = GameState(settings, turn=1)
self.cached_actions = None
self.human_actions = {}
self.UI.setTurn(self.state.turn)
self.UI.bind("w", lambda ev: self.UI.moveSelection((0, -1)))
self.UI.bind("a", lambda ev: self.UI.moveSelection((-1, 0)))
self.UI.bind("s", lambda ev: self.UI.moveSelection((0, 1)))
self.UI.bind("d", lambda ev: self.UI.moveSelection((1, 0)))
self.UI.bind("<Up>", lambda ev: self.UI.moveSelection((0, -1)))
self.UI.bind("<Left>", lambda ev: self.UI.moveSelection((-1, 0)))
self.UI.bind("<Down>", lambda ev: self.UI.moveSelection((0, 1)))
self.UI.bind("<Right>", lambda ev: self.UI.moveSelection((1, 0)))
self.UI.bind("<ButtonPress-1>", lambda ev: self.UI.onMouseClick(ev))
self.UI.bind("l", self.onLoadMatch)
self.UI.bind("k", self.onLoadTurn)
self.UI.bind("o", self.onReloadPlayer)
self.UI.bind("p", self.onSwapPlayer)
self.UI.bind("t", self.onEditTurn)
self.UI.bind("f", self.onAddTeammate)
self.UI.bind("e", self.onAddEnemy)
self.UI.bind("r", self.onRemove)
self.UI.bind("c", self.onClear)
self.UI.bind("<Delete>", self.onRemove)
self.UI.bind("<BackSpace>", self.onRemove)
self.UI.bind("h", self.onEditHP)
self.UI.bind("<space>", self.onShowActions)
self.UI.bind("<Return>", self.onSimulate)
self.UI.bind("n", self.onNextAction)
self.UI.bind("g", self.onSpawnRobots)
self.UI.run()
def onReloadPlayer(self, event):
self.UI.fadeActions()
self.cached_actions = None
self.human_actions = {}
if self.player:
self.player = Player(self.player1_path)
self.player.set_player_id(1)
if self.player2:
self.player2 = Player(self.player2_path)
self.player2.set_player_id(0)
def onSwapPlayer(self, event):
self.UI.clearActions()
self.UI.clearBots()
self.onReloadPlayer(None)
for loc, robot in self.state.robots.iteritems():
self.state.robots[loc][
"player_id"] = 1 - self.state.robots[loc]["player_id"]
self.UI.renderBot(loc, robot.hp, robot.player_id)
def onLoadMatch(self, event):
self.match_id = tkSimpleDialog.askinteger("Load match",
"Enter match number",
parent=self.UI.root,
initialvalue=2588548,
minvalue=1,
maxvalue=99999999)
if self.match_id is not None:
self.moves = getrgmatch.get_match_result(self.match_id)
self.loadBotsfromTurn(1)
def onLoadTurn(self, event):
if self.match_id is not None:
new_turn = tkSimpleDialog.askinteger("Edit turn",
"Enter new turn",
parent=self.UI.root,
initialvalue=self.state.turn,
minvalue=1,
maxvalue=100)
if new_turn is not None:
self.loadBotsfromTurn(new_turn)
def loadBotsfromTurn(self, new_turn):
if self.match_id is not None:
self.UI.clearActions()
self.UI.clearBots()
self.cached_actions = None
self.human_actions = {}
self.state = GameState()
for bot in self.moves[new_turn]:
loc = tuple(bot['location'])
# print bot
self.state.add_robot(loc, bot['player_id'])
self.state.robots[loc].hp = bot['hp']
self.UI.renderBot(loc, bot['hp'], bot['player_id'])
self.UI.setTurn(new_turn)
self.state.turn = new_turn
def onEditTurn(self, event):
new_turn = tkSimpleDialog.askinteger("Edit turn",
"Enter new turn",
parent=self.UI.root,
initialvalue=self.state.turn,
minvalue=1,
maxvalue=100)
if new_turn is not None:
self.UI.fadeActions()
self.cached_actions = None
self.human_actions = {}
self.UI.setTurn(new_turn)
self.state.turn = new_turn
def onRemove(self, event):
self._removeRobot(self.UI.selection)
def _removeRobot(self, loc):
if self.state.is_robot(loc):
self.UI.fadeActions()
self.cached_actions = None
if loc in self.human_actions:
del self.human_actions[loc]
self.state.remove_robot(loc)
self.UI.renderEmpty(loc)
def onAddTeammate(self, event):
self._addRobot(1, self.UI.selection)
def onAddEnemy(self, event):
self._addRobot(0, self.UI.selection)
def _addRobot(self, player_id, loc):
self.UI.fadeActions()
self.cached_actions = None
if self.state.is_robot(loc):
self.state.remove_robot(loc)
if loc in self.human_actions:
del self.human_actions[loc]
self.state.add_robot(loc, player_id)
self.UI.renderBot(loc, 50, player_id)
def onEditHP(self, event):
if self.state.is_robot(self.UI.selection):
robot = self.state.robots[self.UI.selection]
self.UI.fadeActions()
self.cached_actions = None
new_hp = tkSimpleDialog.askinteger("Edit hp",
"Enter new hp",
parent=self.UI.root,
initialvalue=robot.hp,
minvalue=1,
maxvalue=50)
if new_hp is not None:
robot.hp = new_hp
self.UI.renderBot(self.UI.selection, new_hp, robot.player_id)
def getActions(self):
def getPlayerActions(player, player_id):
if player:
actions, _ = player.get_responses(self.state, player_id)
else:
actions = {}
for loc, robot in self.state.robots.iteritems():
if robot.player_id == player_id:
action = self.human_actions.get(loc)
if action or loc not in actions:
actions[loc] = action if action else ('guard', )
return actions
actions = getPlayerActions(self.player, 1)
actions.update(getPlayerActions(self.player2, 0))
return actions
def onClear(self, event):
self.UI.clearActions()
self.UI.clearBots()
self.cached_actions = None
self.human_actions = {}
self.state = GameState(turn=self.state.turn)
def onShowActions(self, event):
if self.state.turn < 100:
# the following is needed since if the turn does not change,
# non-stateless bots behave differently
if self.player and self.turn_repeat:
self.player = Player(self.player1_path)
self.player.set_player_id(1)
if self.player2 and self.turn_repeat:
self.player2 = Player(self.player2_path)
self.player2.set_player_id(0)
self.UI.clearActions()
actions = self.getActions()
self.cached_actions = actions
for loc, action in actions.iteritems():
self.UI.renderAction(loc, action)
self.turn_repeat = True
try:
rgsim_text = self.player._module.rgsim_text
for loc, text in rgsim_text.iteritems():
self.UI.renderText(loc, text)
except AttributeError:
print "No rgsim_text dict found for player 1, skipping..."
except:
print("Error in rgsim_text dict, please ensure keys are " +
"valid locations and values are strings")
def onSimulate(self, event):
if self.state.turn < 100:
self.UI.clearActions()
self.UI.clearBots()
if self.cached_actions is None:
actions = self.getActions()
else:
actions = self.cached_actions
self.state = self.state.apply_actions(actions, spawn=False)
for loc, robot in self.state.robots.iteritems():
self.UI.renderBot(loc, robot.hp, robot.player_id)
self.cached_actions = None
self.human_actions = {}
self.UI.setTurn(self.state.turn)
self.turn_repeat = False
def onNextAction(self, event):
if not self.state.is_robot(self.UI.selection):
return
robot = self.state.robots[self.UI.selection]
action = self.human_actions.get(self.UI.selection)
if action is None and self.cached_actions is not None:
action = self.cached_actions.get(self.UI.selection)
if action is None:
action = ('guard', )
x, y = self.UI.selection
adjacent_locs = ((x, y - 1), (x + 1, y), (x, y + 1), (x - 1, y))
move_locs = [l for l in adjacent_locs if l not in settings.obstacles]
all_actions = [('guard', )]
all_actions += [('move', loc) for loc in move_locs]
all_actions += [('attack', loc) for loc in adjacent_locs]
all_actions += [('suicide', )]
i = (all_actions.index(action) + 1) % len(all_actions)
action = all_actions[i]
if self.cached_actions is not None:
self.cached_actions[self.UI.selection] = action
self.human_actions[self.UI.selection] = action
self.UI.clearAction(self.UI.selection)
self.UI.renderAction(self.UI.selection, action)
def onSpawnRobots(self, event):
all_locs = self.state._get_spawn_locations()
for loc in settings.spawn_coords:
self._removeRobot(loc)
for i, loc in enumerate(all_locs):
player_id = i // settings.spawn_per_player
self._addRobot(player_id, loc)
def test_remove_robot(self):
state = GameState()
state.add_robot((9, 9), 0)
state.remove_robot((9, 9))
self.assertFalse(state.is_robot((9, 9)))
