def test_unit_pos_swap_almost(self):
unit1 = WorldUnit.objects.get(id=1)
unit3 = WorldUnit.objects.get(id=3)
start_battle(self.battle)
battle_unit1 = BattleUnit.objects.get(world_unit=unit1)
battle_unit3 = BattleUnit.objects.get(world_unit=unit3)
order3 = Order.objects.create(
what=Order.MOVE,
target_location_x=battle_unit1.starting_x_pos,
target_location_z=battle_unit1.starting_z_pos + 1)
battle_unit3.world_unit.default_battle_orders = order3
battle_unit3.world_unit.save()
order1 = Order.objects.create(
what=Order.MOVE,
target_location_x=battle_unit3.starting_x_pos,
target_location_z=battle_unit3.starting_z_pos - 1)
battle_unit1.world_unit.default_battle_orders = order1
battle_unit1.world_unit.save()
for i in range(6):
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
battle_tick(self.battle)
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
def test_unit_move(self):
unit = WorldUnit.objects.get(id=1)
start_battle(self.battle)
battle_unit = BattleUnit.objects.get(world_unit=unit)
order = Order.objects.create(
what=Order.MOVE,
target_location_x=battle_unit.starting_x_pos,
target_location_z=battle_unit.starting_z_pos - 1)
unit.default_battle_orders = order
unit.save()
battle_tick(self.battle)
self.battle.refresh_from_db()
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
buit = BattleUnitInTurn.objects.get(
battle_turn=self.battle.get_latest_turn(), battle_unit=battle_unit)
self.assertEqual(buit.x_pos, battle_unit.starting_x_pos)
self.assertEqual(buit.z_pos, battle_unit.starting_z_pos - 1)
order.refresh_from_db()
self.assertTrue(order.done)
battle_tick(self.battle)
self.battle.refresh_from_db()
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
buit = BattleUnitInTurn.objects.get(
battle_turn=self.battle.get_latest_turn(), battle_unit=battle_unit)
self.assertEqual(buit.x_pos, battle_unit.starting_x_pos)
self.assertEqual(buit.z_pos, battle_unit.starting_z_pos - 1)
order.refresh_from_db()
self.assertTrue(order.done)
def test_battle_initialization(self):
self.my_unit = WorldUnit.objects.create(
owner_character_id=7,
world_id=2,
location_id=1003,
name="Commonwealth lord unit",
recruitment_type=WorldUnit.CONSCRIPTED,
type=WorldUnit.LIGHT_INFANTRY,
status=WorldUnit.FOLLOWING,
mobilization_status_since=0,
current_status_since=0,
generation_size=5,
default_battle_orders=Order.objects.create(what=Order.CHARGE))
self.barbarian_unit = WorldUnit.objects.create(
owner_character=None,
world_id=2,
location_id=1003,
name="Barbarian unit",
recruitment_type=WorldUnit.CONSCRIPTED,
type=WorldUnit.LIGHT_INFANTRY,
status=WorldUnit.FOLLOWING,
mobilization_status_since=0,
current_status_since=0,
generation_size=30,
default_battle_orders=Order.objects.create(what=Order.MOVE))
initialize_unit(self.my_unit)
initialize_unit(self.barbarian_unit)
self.tile = Tile.objects.get(id=105)
trigger_battles_in_tile(self.tile)
self.battle = Battle.objects.get(id=1)
self.assertTrue(
WorldUnit.objects.filter(owner_character__isnull=True).exists())
start_battle(self.battle)
self.assertTrue(
BattleOrganization.objects.filter(organization=World.objects.get(
id=2).get_barbaric_state()).exists())
self.assertTrue(
BattleOrganization.objects.filter(organization_id=105).exists())
self.assertEqual(BattleCharacter.objects.count(), 1)
self.assertEqual(BattleUnit.objects.count(), 2)
self.assertEqual(
BattleUnit.objects.filter(battle_side__battle=self.battle).count(),
2)
self.assertEqual(
BattleSoldier.objects.filter(
battle_contubernium__battle_unit__battle_side__battle=self.
battle).count(), 35)
self.assertEqual(
BattleSoldierInTurn.objects.filter(
battle_turn__battle=self.battle).count(), 35)
def test_manpower(self):
start_battle(self.battle)
side0 = self.battle.battleside_set.get(z=False)
self.assertEqual(side0.get_manpower(), 30)
self.assertEqual(side0.get_proportional_strength(), 1 / 3)
side1 = self.battle.battleside_set.get(z=True)
self.assertEqual(side1.get_manpower(), 90)
self.assertEqual(side1.get_proportional_strength(), 3)
def test_start_units_in_flank(self):
unit1 = WorldUnit.objects.get(id=1)
unit1.battle_side_pos = -4
unit1.save()
unit2 = WorldUnit.objects.get(id=2)
unit2.battle_side_pos = 5
unit2.save()
unit3 = WorldUnit.objects.get(id=3)
unit3.battle_side_pos = -5
unit3.save()
start_battle(self.battle)
def test_move_flee(self):
unit3 = WorldUnit.objects.get(id=3)
order3 = Order.objects.create(what=Order.FLEE)
unit3.default_battle_orders = order3
unit3.save()
start_battle(self.battle)
battle_unit3 = BattleUnit.objects.get(world_unit=unit3)
battle_tick(self.battle)
unit3_contubernia = BattleContuberniumInTurn.objects.filter(
battle_turn=self.battle.get_latest_turn(),
battle_contubernium__battle_unit=battle_unit3)
def test_battle_orders_flee(self):
self.my_unit = WorldUnit.objects.create(
owner_character_id=7,
world_id=2,
location_id=1003,
origin_id=1003,
name="Commonwealth lord unit",
recruitment_type=WorldUnit.CONSCRIPTION,
type=WorldUnit.INFANTRY,
status=WorldUnit.FOLLOWING,
mobilization_status_since=0,
current_status_since=0,
generation_size=30,
default_battle_orders=Order.objects.create(what=Order.CHARGE)
)
self.barbarian_unit = WorldUnit.objects.create(
owner_character=None,
world_id=2,
location_id=1003,
origin_id=1003,
name="Barbarian unit",
recruitment_type=WorldUnit.CONSCRIPTION,
type=WorldUnit.INFANTRY,
status=WorldUnit.FOLLOWING,
mobilization_status_since=0,
current_status_since=0,
generation_size=5,
default_battle_orders=Order.objects.create(what=Order.MOVE)
)
initialize_unit(self.my_unit)
initialize_unit(self.barbarian_unit)
self.tile = Tile.objects.get(id=105)
trigger_battles_in_tile(self.tile)
self.battle = Battle.objects.get(id=1)
self.assertTrue(
WorldUnit.objects.filter(owner_character__isnull=True).exists())
start_battle(self.battle)
battle_unit = BattleUnit.objects.get(owner=None)
self.assertEqual(
battle_unit.get_order().what, Order.FLEE)
battle_tick(self.battle)
battle_unit = BattleUnit.objects.get(owner=None)
self.assertEqual(
battle_unit.get_order().what, Order.FLEE)
def test_battle_with_barbarians(self):
world = World.objects.get(id=2)
unit_of_kingrom_member = WorldUnit.objects.get(id=4)
initialize_unit(unit_of_kingrom_member)
kingdom_member = unit_of_kingrom_member.owner_character
settlement = kingdom_member.location
initialize_settlement(settlement)
generate_barbarian_unit(30, settlement)
worldwide_trigger_battles(world)
self.assertTrue(settlement.tile.get_current_battles().exists())
battle = settlement.tile.get_current_battles()[0]
start_battle(battle)
battle_tick(battle)
generate_barbarian_unit(30, settlement)
battle_joins(battle)
battle_tick(battle)
def test_move_charge(self):
unit3 = WorldUnit.objects.get(id=3)
order3 = Order.objects.create(what=Order.CHARGE)
unit3.default_battle_orders = order3
unit3.default_battle_orders.save()
start_battle(self.battle)
battle_unit3 = BattleUnit.objects.get(world_unit=unit3)
battle_tick(self.battle)
unit3_contubernia = BattleContuberniumInTurn.objects.filter(
battle_turn=self.battle.get_latest_turn(),
battle_contubernium__battle_unit=battle_unit3)
for bcuit in unit3_contubernia:
self.assertEqual(bcuit.z_pos,
bcuit.battle_contubernium.starting_z_pos - 1)
def test_start_battle(self):
start_battle(self.battle)
self.assertTrue(BattleContubernium.objects.exists())
self.assertEqual(BattleContubernium.objects.count(), 16)
self.assertTrue(BattleSoldier.objects.exists())
self.assertEqual(BattleSoldier.objects.count(), 120)
self.assertTrue(BattleContuberniumInTurn.objects.exists())
self.assertEqual(BattleContuberniumInTurn.objects.count(), 16)
self.assertTrue(BattleSoldierInTurn.objects.exists())
self.assertEqual(BattleSoldierInTurn.objects.count(), 120)
for npc in NPC.objects.all():
self.assertTrue(
BattleSoldier.objects.filter(world_npc=npc).exists())
response = self.client.get(self.battle.get_absolute_url())
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse('battle:info', kwargs={'battle_id': self.battle.id}))
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse('battle:battlefield_iframe',
kwargs={'battle_id': self.battle.id}))
self.assertEqual(response.status_code, 200)
self.assertEqual(
BattleUnitInTurn.objects.get(
battle_turn=self.battle.get_latest_turn(),
battle_unit__world_unit__id=2).order.what, Order.CHARGE)
self.assertEqual(
BattleUnitInTurn.objects.get(
battle_turn=self.battle.get_latest_turn(),
battle_unit__world_unit__id=1).order.what,
Order.ADVANCE_IN_FORMATION)
def test_unit_superposition(self):
unit1 = WorldUnit.objects.get(id=1)
unit3 = WorldUnit.objects.get(id=3)
start_battle(self.battle)
battle_unit1 = BattleUnit.objects.get(world_unit=unit1)
battle_unit3 = BattleUnit.objects.get(world_unit=unit3)
order = Order.objects.create(
what=Order.MOVE,
target_location_x=battle_unit1.starting_x_pos,
target_location_z=battle_unit1.starting_z_pos)
battle_unit3.world_unit.default_battle_orders = order
battle_unit3.world_unit.save()
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
battle_tick(self.battle)
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
battle_tick(self.battle)
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
battle_tick(self.battle)
def test_unit_formation_follow(self):
start_battle(self.battle)
unit = WorldUnit.objects.get(id=1)
battle_unit = BattleUnit.objects.get(world_unit=unit)
battle_tick(self.battle)
self.battle.refresh_from_db()
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
buit = BattleUnitInTurn.objects.get(
battle_turn=self.battle.get_latest_turn(), battle_unit=battle_unit)
self.assertEqual(buit.x_pos, battle_unit.starting_x_pos)
self.assertEqual(buit.z_pos, battle_unit.starting_z_pos - 1)
battle_tick(self.battle)
self.battle.refresh_from_db()
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
buit = BattleUnitInTurn.objects.get(
battle_turn=self.battle.get_latest_turn(), battle_unit=battle_unit)
self.assertEqual(buit.x_pos, battle_unit.starting_x_pos)
self.assertEqual(buit.z_pos, battle_unit.starting_z_pos - 2)
def test_orders_view_when_started(self):
start_battle(self.battle)
response = self.client.get(reverse(
'battle:set_orders', kwargs={'battle_id': self.battle.id}),
follow=True)
self.assertEqual(response.status_code, 200)
def test_info_view_when_started(self):
start_battle(self.battle)
response = self.client.get(
reverse('battle:info', kwargs={'battle_id': self.battle.id}))
self.assertEqual(response.status_code, 200)
def battle_starts(self):
for battle in Battle.objects.filter(tile__world=self.world,
current=True,
started=False):
start_battle(battle)
def test_battle_create_from_units_with_allies(self):
world = World.objects.get(id=2)
worldwide_trigger_battles(world)
self.assertTrue(Battle.objects.exists())
self.battle = Battle.objects.get(id=1)
self.assertEqual(self.battle.battleside_set.count(), 2)
self.assertTrue(
BattleOrganization.objects.filter(
side__battle=self.battle, organization=self.kingdom).exists())
self.assertTrue(
BattleOrganization.objects.filter(
side__battle=self.battle, organization=self.horde).exists())
self.assertTrue(
BattleOrganization.objects.filter(
side__battle=self.battle,
organization=self.commonwealth).exists())
self.assertEqual(BattleOrganization.objects.count(), 3)
self.assertTrue(
BattleOrganization.objects.get(organization=self.kingdom).side.z !=
BattleOrganization.objects.get(organization=self.horde).side.z)
self.assertTrue(
BattleOrganization.objects.get(
organization=self.commonwealth).side.z !=
BattleOrganization.objects.get(organization=self.horde).side.z)
self.assertTrue(BattleCharacter.objects.exists())
self.assertTrue(
BattleCharacter.objects.filter(
battle_organization__organization=self.kingdom, ).exists())
self.assertTrue(
BattleCharacter.objects.filter(
battle_organization__organization=self.horde, ).exists())
self.assertTrue(
BattleCharacter.objects.filter(
battle_organization__organization=self.commonwealth,
).exists())
self.assertEqual(BattleCharacter.objects.count(), 3)
self.assertTrue(BattleUnit.objects.exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_warrior,
starting_manpower=30).exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_commonwealth,
starting_manpower=30).exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_warrior2,
starting_manpower=60).exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_kingdom,
starting_manpower=100).exists())
self.assertEqual(BattleUnit.objects.count(), 4)
response = self.client.get(self.battle.get_absolute_url(), follow=True)
self.assertEqual(response.status_code, 200)
start_battle(self.battle)
battle_tick(self.battle)
def worldwide_battle_starts(world: World):
for battle in Battle.objects.filter(
tile__world=world, current=True, started=False
):
start_battle(battle)
def test_move_while_unit_blocks(self):
unit1 = WorldUnit.objects.get(id=1)
unit3 = WorldUnit.objects.get(id=3)
order3 = Order.objects.create(what=Order.STAND)
unit3.battle_line = 2
unit3.default_battle_orders = order3
unit3.save()
start_battle(self.battle)
battle_unit1 = BattleUnit.objects.get(world_unit=unit1)
battle_unit3 = BattleUnit.objects.get(world_unit=unit3)
battle_tick(self.battle)
unit1_contubernia = BattleContuberniumInTurn.objects.filter(
battle_turn=self.battle.get_latest_turn(),
battle_contubernium__battle_unit=battle_unit1)
for bcuit in unit1_contubernia:
self.assertEqual(bcuit.z_pos,
bcuit.battle_contubernium.starting_z_pos - 1)
battle_tick(self.battle)
unit1_contubernia = BattleContuberniumInTurn.objects.filter(
battle_turn=self.battle.get_latest_turn(),
battle_contubernium__battle_unit=battle_unit1)
for bcuit in unit1_contubernia:
self.assertEqual(bcuit.z_pos,
bcuit.battle_contubernium.starting_z_pos - 2)
battle_tick(self.battle)
unit1_contubernia = BattleContuberniumInTurn.objects.filter(
battle_turn=self.battle.get_latest_turn(),
battle_contubernium__battle_unit=battle_unit1)
for bcuit in unit1_contubernia:
self.assertEqual(bcuit.z_pos,
bcuit.battle_contubernium.starting_z_pos - 2)
battle_tick(self.battle)
unit1_contubernia = BattleContuberniumInTurn.objects.filter(
battle_turn=self.battle.get_latest_turn(),
battle_contubernium__battle_unit=battle_unit1)
# DONT TEST HERE BECAUSE OF MIXED STATE
battle_tick(self.battle)
unit1_contubernia = BattleContuberniumInTurn.objects.filter(
battle_turn=self.battle.get_latest_turn(),
battle_contubernium__battle_unit=battle_unit1)
for bcuit in unit1_contubernia:
self.assertEqual(bcuit.z_pos,
bcuit.battle_contubernium.starting_z_pos - 3)
battle_tick(self.battle)
unit1_contubernia = BattleContuberniumInTurn.objects.filter(
battle_turn=self.battle.get_latest_turn(),
battle_contubernium__battle_unit=battle_unit1)
for bcuit in unit1_contubernia:
self.assertEqual(bcuit.z_pos,
bcuit.battle_contubernium.starting_z_pos - 4)
def test_move_avoiding_wall_obstacle(self):
unit1 = WorldUnit.objects.get(id=1)
unit3 = WorldUnit.objects.get(id=3)
start_battle(self.battle)
battle_unit1 = BattleUnit.objects.get(world_unit=unit1)
battle_unit3 = BattleUnit.objects.get(world_unit=unit3)
obstacles = BattleContuberniumInTurn.objects.filter(
battle_contubernium__battle_unit=battle_unit1)
contub1 = obstacles[0]
contub1.x_pos = 100
contub1.z_pos = 99
contub1.save()
contub1 = obstacles[1]
contub1.x_pos = 100
contub1.z_pos = 101
contub1.save()
contub1 = obstacles[2]
contub1.x_pos = 100
contub1.z_pos = 100
contub1.save()
contub3 = BattleContuberniumInTurn.objects.filter(
battle_contubernium__battle_unit=battle_unit3)[0]
contub3.x_pos = 99
contub3.z_pos = 100
contub3.save()
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
self.assertFalse(contub1.desires_pos)
self.assertEqual(contub1.x_pos, 100)
self.assertEqual(contub1.z_pos, 100)
self.assertFalse(contub1.moved_this_turn)
self.assertFalse(contub3.desires_pos)
self.assertEqual(contub3.x_pos, 99)
self.assertEqual(contub3.z_pos, 100)
self.assertFalse(contub3.moved_this_turn)
contub3_movement_target = Coordinates(x=101, z=100)
def target_distance_function(coords):
return euclidean_distance(coords, contub3_movement_target)
optimistic_move_desire_formulation(contub3, target_distance_function)
contub1.refresh_from_db()
self.assertFalse(contub1.desires_pos)
self.assertEqual(contub1.x_pos, 100)
self.assertEqual(contub1.z_pos, 100)
self.assertFalse(contub1.moved_this_turn)
contub3.refresh_from_db()
self.assertTrue(contub3.desires_pos)
self.assertEqual(contub3.desired_x_pos, 100)
self.assertEqual(contub3.desired_z_pos, 100)
self.assertEqual(contub3.x_pos, 99)
self.assertEqual(contub3.z_pos, 100)
self.assertFalse(contub3.moved_this_turn)
optimistic_move_desire_resolving(self.battle)
contub1.refresh_from_db()
self.assertFalse(contub1.desires_pos)
self.assertEqual(contub1.x_pos, 100)
self.assertEqual(contub1.z_pos, 100)
self.assertFalse(contub1.moved_this_turn)
contub3.refresh_from_db()
self.assertFalse(contub3.desires_pos)
self.assertEqual(contub3.x_pos, 99)
self.assertEqual(contub3.z_pos, 100)
self.assertFalse(contub3.moved_this_turn)
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
safe_move(contub3, target_distance_function)
contub3.refresh_from_db()
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
safe_move(contub3, target_distance_function)
contub3.refresh_from_db()
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
safe_move(contub3, target_distance_function)
contub3.refresh_from_db()
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
safe_move(contub3, target_distance_function)
contub3.refresh_from_db()
self.assertFalse(
self.battle.get_latest_turn().test_contubernia_superposition())
contub3.refresh_from_db()
self.assertFalse(contub3.desires_pos)
self.assertEqual(contub3.x_pos, 101)
self.assertEqual(contub3.z_pos, 100)
self.assertTrue(contub3.moved_this_turn)
def test_battle_create_from_units_with_allies_joining_during_battle2(self):
self.unit_of_commonwealth.location_id = 1001
self.unit_of_commonwealth.save()
turn_processor = TurnProcessor(World.objects.get(id=2))
turn_processor.trigger_battles()
self.assertTrue(Battle.objects.exists())
self.battle = Battle.objects.get(id=1)
self.assertEqual(self.battle.battleside_set.count(), 2)
self.assertTrue(
BattleOrganization.objects.filter(
side__battle=self.battle, organization=self.kingdom).exists())
self.assertTrue(
BattleOrganization.objects.filter(
side__battle=self.battle, organization=self.horde).exists())
self.assertFalse(
BattleOrganization.objects.filter(
side__battle=self.battle,
organization=self.commonwealth).exists())
self.assertEqual(BattleOrganization.objects.count(), 2)
self.assertEqual(
self.unit_of_commonwealth.owner_character.
get_battle_participating_in(), None)
self.assertTrue(
BattleOrganization.objects.get(organization=self.kingdom).side.z !=
BattleOrganization.objects.get(organization=self.horde).side.z)
self.assertTrue(BattleCharacter.objects.exists())
self.assertTrue(
BattleCharacter.objects.filter(
battle_organization__organization=self.kingdom, ).exists())
self.assertTrue(
BattleCharacter.objects.filter(
battle_organization__organization=self.horde, ).exists())
self.assertFalse(
BattleCharacter.objects.filter(
battle_organization__organization=self.commonwealth,
).exists())
self.assertEqual(BattleCharacter.objects.count(), 2)
self.assertTrue(BattleUnit.objects.exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_warrior,
starting_manpower=30).exists())
self.assertFalse(
BattleUnit.objects.filter(world_unit=self.unit_of_commonwealth,
starting_manpower=30).exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_warrior2,
starting_manpower=60).exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_kingdom,
starting_manpower=100).exists())
self.assertEqual(BattleUnit.objects.count(), 3)
response = self.client.get(self.battle.get_absolute_url(), follow=True)
self.assertEqual(response.status_code, 200)
start_battle(self.battle)
battle_tick(self.battle)
self.unit_of_commonwealth.location_id = 1007
self.unit_of_commonwealth.save()
turn_processor.battle_joins()
self.assertTrue(
BattleOrganization.objects.filter(
side__battle=self.battle,
organization=self.commonwealth).exists())
self.assertEqual(BattleOrganization.objects.count(), 3)
self.assertTrue(
BattleOrganization.objects.get(
organization=self.commonwealth).side.z !=
BattleOrganization.objects.get(organization=self.horde).side.z)
self.assertTrue(
BattleCharacter.objects.filter(
battle_organization__organization=self.commonwealth,
).exists())
self.assertEqual(BattleCharacter.objects.count(), 3)
self.assertTrue(BattleUnit.objects.exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_warrior,
starting_manpower=30).exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_commonwealth,
starting_manpower=30).exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_warrior2,
starting_manpower=60).exists())
self.assertTrue(
BattleUnit.objects.filter(world_unit=self.unit_of_kingdom,
starting_manpower=100).exists())
self.assertEqual(BattleUnit.objects.count(), 4)
self.assertEqual(
self.unit_of_commonwealth.owner_character.
get_battle_participating_in(), self.battle)
battle_tick(self.battle)
def start(modeladmin, request, queryset):
for battle in queryset.all():
start_battle(battle)
