def test_field_input_over_ideal_workload(self):
settlement = Settlement.objects.get(name="Small Valley")
buildings = Building.objects.get(
type=Building.GRAIN_FIELD, settlement=settlement
)
buildings.quantity = 100
buildings.save()
for i in range(20):
NPC.objects.create(
name="foo",
male=False,
able=True,
age_months=20*12,
residence=None,
origin=settlement,
location=settlement,
workplace=buildings,
unit=None,
trained_soldier=False,
skill_fighting=0
)
turn_processor = TurnProcessor(settlement.tile.world)
turn_processor.do_building_production(buildings)
buildings.refresh_from_db()
self.assertEqual(buildings.quantity, 100)
self.assertEqual(buildings.worker.count(), 20)
self.assertEqual(
buildings.field_production_counter,
112
)
def test_guild_input(self):
settlement = Settlement.objects.get(name="Small Valley")
guild = Building.objects.get(
type=Building.GUILD, settlement=settlement
)
for i in range(10):
NPC.objects.create(
name="foo",
male=False,
able=True,
age_months=20*12,
residence=None,
origin=settlement,
location=settlement,
workplace=guild,
unit=None,
trained_soldier=False,
skill_fighting=0
)
turn_processor = TurnProcessor(settlement.tile.world)
turn_processor.do_building_production(guild)
guild.refresh_from_db()
self.assertEqual(guild.quantity, 1)
self.assertEqual(guild.worker.count(), 10)
self.assertEqual(guild.field_production_counter, 10)
def test_population_generation_in_empty_settlement(self):
settlement = Settlement.objects.get(name="Small Fynkah")
settlement.npc_set.all().delete()
settlement.update_population()
self.assertEqual(settlement.population, 0)
processor = TurnProcessor(settlement.tile.world)
processor.do_settlement_population_changes(settlement)
self.assertEqual(settlement.population, 5)
def test_tax_countdown(self):
state = Organization.objects.get(name="Small Kingdom")
state.tax_countdown = 7
state.save()
turn_processor = TurnProcessor(state.world)
turn_processor.do_taxes()
state.refresh_from_db()
self.assertEqual(state.tax_countdown, 6)
def test_guild_default(self):
initialize_settlement(self.settlement)
turn_processor = TurnProcessor(self.settlement.tile.world)
turn_processor.do_settlement_job_updates(self.settlement)
self.assertEqual(
self.settlement.guilds_setting, Settlement.GUILDS_KEEP)
self.assertTrue(
self.settlement.get_residents().filter(
workplace__type=Building.GRAIN_FIELD).exists())
self.assertFalse(
self.settlement.get_residents().filter(
workplace__type=Building.GUILD).exists())
def test_reset_production(self):
settlement = Settlement.objects.get(name="Small Valley")
buildings = Building.objects.get(
type=Building.GRAIN_FIELD, settlement=settlement
)
buildings.field_production_counter = 1000
buildings.save()
settlement.tile.world.current_turn = 8
settlement.tile.world.save()
turn_processor = TurnProcessor(settlement.tile.world)
turn_processor.do_building_production(buildings)
buildings.refresh_from_db()
self.assertEqual(buildings.field_production_counter, 0)
def test_guild_promote(self):
self.settlement.guilds_setting = Settlement.GUILDS_PROMOTE
self.settlement.save()
initialize_settlement(self.settlement)
turn_processor = TurnProcessor(self.settlement.tile.world)
turn_processor.do_settlement_job_updates(self.settlement)
self.assertTrue(
self.settlement.get_residents().filter(
workplace__type=Building.GRAIN_FIELD).exists())
self.assertTrue(
self.settlement.get_residents().filter(
workplace__type=Building.GUILD).exists())
self.assertEqual(
self.settlement.get_residents().filter(
workplace__type=Building.GUILD).count(), 10)
def test_conquest_success(self):
tile = Tile.objects.get(name="More mountains")
conqueror = Organization.objects.get(id=105)
tile_event = TileEvent.objects.create(tile=tile,
type=TileEvent.CONQUEST,
organization=conqueror,
counter=100000,
start_turn=0)
processor = TurnProcessor(tile.world)
processor.do_conquests()
tile.refresh_from_db()
self.assertEqual(tile.controlled_by, conqueror)
tile_event.refresh_from_db()
self.assertEqual(tile_event.end_turn, 0)
self.assertNotEqual(tile_event.end_turn, None)
def test_basic_tax(self):
settlement = Settlement.objects.get(name="Small Valley")
guild = settlement.building_set.get(type=Building.GUILD)
guild.field_production_counter = 100
guild.save()
turn_processor = TurnProcessor(settlement.tile.world)
turn_processor.do_taxes()
state = settlement.tile.controlled_by.get_violence_monopoly()
self.assertEqual(state.tax_countdown, 12)
char1 = Character.objects.get(id=4)
self.assertEqual(char1.cash, 10000 + 100 * 6 / 2)
char2 = Character.objects.get(id=8)
self.assertEqual(char2.cash, 10000 + 100 * 6 / 2)
def test_battle_with_barbarians(self):
world = World.objects.get(id=2)
turn_processor = TurnProcessor(world)
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)
turn_processor.trigger_battles()
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_travel_to_other_tile(self):
response = self.client.post(reverse('world:travel'),
data={'target_settlement_id': 1002},
follow=True)
self.assertRedirects(response, reverse('world:travel'))
character = Character.objects.get(id=1)
self.assertEqual(character.location_id, 1001)
self.assertEqual(character.hours_in_turn_left, 15 * 24)
self.assertEqual(character.travel_destination_id, 1002)
turn_processor = TurnProcessor(character.world)
turn_processor.do_travels()
character.refresh_from_db()
self.assertEqual(character.location_id, 1002)
self.assertEqual(character.hours_in_turn_left, 15 * 24 - 52)
self.assertEqual(character.travel_destination_id, None)
def test_field_output_after_ideal_input(self):
settlement = Settlement.objects.get(name="Small Valley")
buildings = Building.objects.get(
type=Building.GRAIN_FIELD, settlement=settlement
)
buildings.quantity = 100
buildings.field_production_counter = 1000
buildings.save()
settlement.tile.world.current_turn = 6
settlement.tile.world.save()
for i in range(10):
NPC.objects.create(
name="foo",
male=False,
able=True,
age_months=20*12,
residence=None,
origin=settlement,
location=settlement,
workplace=buildings,
unit=None,
trained_soldier=False,
skill_fighting=0
)
turn_processor = TurnProcessor(settlement.tile.world)
turn_processor.do_building_production(buildings)
buildings.refresh_from_db()
self.assertEqual(buildings.quantity, 100)
self.assertEqual(buildings.worker.count(), 10)
self.assertEqual(
buildings.field_production_counter,
math.floor(1000 * 6/7)
)
bushel_object = settlement.get_default_granary().inventoryitem_set.get(
type=InventoryItem.GRAIN
)
self.assertEqual(bushel_object.quantity, math.floor(100 * 1/7 * 2.4))
def test_guild_restrict(self):
initialize_settlement(self.settlement)
turn_processor = TurnProcessor(self.settlement.tile.world)
turn_processor.do_settlement_job_updates(self.settlement)
guild = self.settlement.building_set.get(type=Building.GUILD)
for worker in list(self.settlement.get_residents().filter(
workplace__type=Building.GRAIN_FIELD))[:30]:
worker.workplace = guild
worker.save()
self.assertEqual(
self.settlement.get_residents().filter(
workplace__type=Building.GUILD).count(), 30)
self.settlement.guilds_setting = Settlement.GUILDS_RESTRICT
self.settlement.save()
turn_processor.do_settlement_job_updates(self.settlement)
self.assertTrue(
self.settlement.get_residents().filter(
workplace__type=Building.GRAIN_FIELD).exists())
self.assertTrue(
self.settlement.get_residents().filter(
workplace__type=Building.GUILD).exists())
self.assertTrue(
0 <
self.settlement.get_residents().filter(
workplace__type=Building.GUILD).count() <= 20)
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)
