def test_uniform(self):
fit = Fit()
item = Ship(self.mktype(attrs={
AttrId.hp: 1,
AttrId.em_dmg_resonance: 0.8,
AttrId.therm_dmg_resonance: 0.8,
AttrId.kin_dmg_resonance: 0.8,
AttrId.expl_dmg_resonance: 0.8,
AttrId.armor_hp: 10,
AttrId.armor_em_dmg_resonance: 0.4,
AttrId.armor_therm_dmg_resonance: 0.4,
AttrId.armor_kin_dmg_resonance: 0.4,
AttrId.armor_expl_dmg_resonance: 0.4,
AttrId.shield_capacity: 100,
AttrId.shield_em_dmg_resonance: 0.2,
AttrId.shield_therm_dmg_resonance: 0.2,
AttrId.shield_kin_dmg_resonance: 0.2,
AttrId.shield_expl_dmg_resonance: 0.2}).id)
fit.ship = item
# Verification
results = item.get_ehp(DmgProfile(1, 1, 1, 1))
self.assertAlmostEqual(results.hull, 1.25)
self.assertAlmostEqual(results.armor, 25)
self.assertAlmostEqual(results.shield, 500)
self.assertAlmostEqual(results.total, 526.25)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_non_uniform(self):
fit = Fit()
item = Ship(self.mktype(attrs={
AttrId.hp: 10,
AttrId.em_dmg_resonance: 0.9,
AttrId.therm_dmg_resonance: 0.8,
AttrId.kin_dmg_resonance: 0.7,
AttrId.expl_dmg_resonance: 0.6,
AttrId.armor_hp: 50,
AttrId.armor_em_dmg_resonance: 0.4,
AttrId.armor_therm_dmg_resonance: 0.6,
AttrId.armor_kin_dmg_resonance: 0.8,
AttrId.armor_expl_dmg_resonance: 0.9,
AttrId.shield_capacity: 600,
AttrId.shield_em_dmg_resonance: 1.0,
AttrId.shield_therm_dmg_resonance: 0.8,
AttrId.shield_kin_dmg_resonance: 0.6,
AttrId.shield_expl_dmg_resonance: 0.5}).id)
fit.ship = item
# Verification
results = item.get_ehp(DmgProfile(25, 6, 8.333, 1))
self.assertAlmostEqual(results.hull, 11.957, places=3)
self.assertAlmostEqual(results.armor, 95.276, places=3)
self.assertAlmostEqual(results.shield, 685.551, places=3)
self.assertAlmostEqual(results.total, 792.783, places=3)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_item_attr_hp_all_absent(self):
fit = Fit()
item = Ship(self.mktype(attrs={
AttrId.em_dmg_resonance: 0.9,
AttrId.therm_dmg_resonance: 0.8,
AttrId.kin_dmg_resonance: 0.7,
AttrId.expl_dmg_resonance: 0.6,
AttrId.armor_em_dmg_resonance: 0.4,
AttrId.armor_therm_dmg_resonance: 0.6,
AttrId.armor_kin_dmg_resonance: 0.8,
AttrId.armor_expl_dmg_resonance: 0.9,
AttrId.shield_em_dmg_resonance: 1.0,
AttrId.shield_therm_dmg_resonance: 0.8,
AttrId.shield_kin_dmg_resonance: 0.6,
AttrId.shield_expl_dmg_resonance: 0.5}).id)
fit.ship = item
# Verification
results = item.get_ehp(DmgProfile(25, 6, 8.333, 1))
self.assertAlmostEqual(results.hull, 0)
self.assertAlmostEqual(results.armor, 0)
self.assertAlmostEqual(results.shield, 0)
self.assertAlmostEqual(results.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_item_not_loaded(self):
fit = Fit()
item = Ship(self.allocate_type_id())
fit.ship = item
# Verification
results = item.get_ehp(DmgProfile(1, 1, 1, 1))
self.assertAlmostEqual(results.hull, 0)
self.assertAlmostEqual(results.armor, 0)
self.assertAlmostEqual(results.shield, 0)
self.assertAlmostEqual(results.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_output_ship_attr_absent(self):
self.fit.ship = Ship(self.mktype().id)
# Verification
self.assertEqual(self.fit.stats.fighter_squads_light.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_modified(self):
# Make sure modified powergrid values are taken
self.fit.ship = Ship(self.mktype(attrs={AttrId.power_output: 50}).id)
src_attr = self.mkattr()
modifier = self.mkmod(
affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=AttrId.power,
operator=ModOperator.post_mul,
affector_attr_id=src_attr.id)
mod_effect = self.mkeffect(
category_id=EffectCategoryId.passive,
modifiers=[modifier])
item = ModuleHigh(
self.mktype(
attrs={AttrId.power: 50, src_attr.id: 2},
effects=(self.effect, mod_effect)).id,
state=State.online)
self.fit.modules.high.append(item)
# Action
error = self.get_error(item, Restriction.powergrid)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.output, 50)
self.assertEqual(error.total_use, 100)
self.assertEqual(error.item_use, 100)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_mix_usage_zero(self):
# If some item has zero usage and powergrid error is still raised, check
# it's not raised for item with zero usage
self.fit.ship = Ship(self.mktype(attrs={AttrId.power_output: 50}).id)
item1 = ModuleHigh(
self.mktype(attrs={AttrId.power: 100}, effects=[self.effect]).id,
state=State.online)
self.fit.modules.high.append(item1)
item2 = ModuleHigh(
self.mktype(attrs={AttrId.power: 0}, effects=[self.effect]).id,
state=State.online)
self.fit.modules.high.append(item2)
# Action
error1 = self.get_error(item1, Restriction.powergrid)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.output, 50)
self.assertEqual(error1.total_use, 100)
self.assertEqual(error1.item_use, 100)
# Action
error2 = self.get_error(item2, Restriction.powergrid)
# Verification
self.assertIsNone(error2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_item_attr_hp_all_absent(self):
fit = Fit()
item = Ship(
self.mktype(
attrs={
AttrId.em_dmg_resonance: 0.8,
AttrId.therm_dmg_resonance: 0.8,
AttrId.kin_dmg_resonance: 0.8,
AttrId.expl_dmg_resonance: 0.8,
AttrId.armor_em_dmg_resonance: 0.4,
AttrId.armor_therm_dmg_resonance: 0.4,
AttrId.armor_kin_dmg_resonance: 0.4,
AttrId.armor_expl_dmg_resonance: 0.4,
AttrId.shield_em_dmg_resonance: 0.2,
AttrId.shield_therm_dmg_resonance: 0.2,
AttrId.shield_kin_dmg_resonance: 0.2,
AttrId.shield_expl_dmg_resonance: 0.2
}).id)
fit.ship = item
# Verification
self.assertAlmostEqual(item.worst_case_ehp.hull, 0)
self.assertAlmostEqual(item.worst_case_ehp.armor, 0)
self.assertAlmostEqual(item.worst_case_ehp.shield, 0)
self.assertAlmostEqual(item.worst_case_ehp.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_output_ship_attr_absent(self):
self.fit.ship = Ship(self.mktype().id)
# Verification
self.assertAlmostEqual(self.fit.stats.cpu.output, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_multiple(self):
# Check that error works for multiple items
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.launcher_slots_left: 1
}).id)
item_type = self.mktype(effects=[self.effect])
item1 = ModuleHigh(item_type.id)
item2 = ModuleHigh(item_type.id)
self.fit.modules.high.append(item1)
self.fit.modules.high.append(item2)
# Action
error1 = self.get_error(item1, Restriction.launcher_slot)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.used, 2)
self.assertEqual(error1.total, 1)
# Action
error2 = self.get_error(item2, Restriction.launcher_slot)
# Verification
self.assertIsNotNone(error2)
self.assertEqual(error2.used, 2)
self.assertEqual(error2.total, 1)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass(self):
# When total consumption is less than output, no errors should be raised
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.upgrade_capacity: 50
}).id)
item1 = Rig(
self.mktype(attrs={
AttrId.upgrade_cost: 25
}, effects=[self.effect]).id)
self.fit.rigs.add(item1)
item2 = Rig(
self.mktype(attrs={
AttrId.upgrade_cost: 20
}, effects=[self.effect]).id)
self.fit.rigs.add(item2)
# Action
error1 = self.get_error(item1, Restriction.calibration)
# Verification
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.calibration)
# Verification
self.assertIsNone(error2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_multiple(self):
# Check that error works for multiple items
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.fighter_light_slots: 1
}).id)
item_type = self.mktype(attrs={AttrId.fighter_squadron_is_light: 1})
item1 = FighterSquad(item_type.id)
item2 = FighterSquad(item_type.id)
self.fit.fighters.add(item1)
self.fit.fighters.add(item2)
# Action
error1 = self.get_error(item1, Restriction.fighter_squad_light)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.used, 2)
self.assertEqual(error1.total, 1)
# Action
error2 = self.get_error(item2, Restriction.fighter_squad_light)
# Verification
self.assertIsNotNone(error2)
self.assertEqual(error2.used, 2)
self.assertEqual(error2.total, 1)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_double_run_unsynced(self):
# Setup
ship = Ship(self.make_ship_type((0.5, 0.65, 0.75, 0.9)).id)
self.fit.ship = ship
rah_type = self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6, 1000)
rah1 = ModuleLow(rah_type.id, state=State.active)
rah2 = ModuleLow(rah_type.id, state=State.overload)
self.fit.modules.low.equip(rah1)
self.fit.modules.low.equip(rah2)
# Verification
self.assertAlmostEqual(rah1.attrs[self.armor_em.id], 0.975, places=3)
self.assertAlmostEqual(rah1.attrs[self.armor_therm.id],
0.835,
places=3)
self.assertAlmostEqual(rah1.attrs[self.armor_kin.id], 0.83, places=3)
self.assertAlmostEqual(rah1.attrs[self.armor_expl.id], 0.76, places=3)
self.assertAlmostEqual(rah2.attrs[self.armor_em.id], 0.979, places=3)
self.assertAlmostEqual(rah2.attrs[self.armor_therm.id], 0.91, places=3)
self.assertAlmostEqual(rah2.attrs[self.armor_kin.id], 0.796, places=3)
self.assertAlmostEqual(rah2.attrs[self.armor_expl.id], 0.715, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.479, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.5, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.509, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.509, places=3)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_unexpected_exception(self):
# Setup
ship = Ship(self.make_ship_type((0.5, 0.65, 0.75, 0.9)).id)
self.fit.ship = ship
# Set cycle time to zero to force exception
rah = ModuleLow(self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6, 0).id,
state=State.active)
self.fit.modules.low.equip(rah)
# Verification
self.assertAlmostEqual(rah.attrs[self.armor_em.id], 0.85)
self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 0.85)
self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 0.85)
self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 0.85)
self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.425)
self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.5525)
self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.6375)
self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.765)
self.assert_log_entries(1)
log_record = self.log[0]
self.assertEqual(log_record.name, 'eos.sim.reactive_armor_hardener')
self.assertEqual(log_record.levelno, logging.WARNING)
self.assertEqual(
log_record.msg,
'unexpected exception, setting unsimulated resonances')
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
def test_no_loop_half_history(self):
# Setup
ship = Ship(self.make_ship_type((0.5, 0.65, 0.75, 0.9)).id)
self.fit.ship = ship
rah_type = self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6, 1000)
rah1 = ModuleLow(rah_type.id, state=State.active)
rah2 = ModuleLow(rah_type.id, state=State.overload)
self.fit.modules.low.equip(rah1)
self.fit.modules.low.equip(rah2)
# Verification
# Same as previous test, but here whole history is just 5 ticks, and we
# cannot ignore all of them - here we should ignore just 2 first ticks
self.assertAlmostEqual(rah1.attrs[self.armor_em.id], 0.94, places=3)
self.assertAlmostEqual(rah1.attrs[self.armor_therm.id], 0.88, places=3)
self.assertAlmostEqual(rah1.attrs[self.armor_kin.id], 0.82, places=3)
self.assertAlmostEqual(rah1.attrs[self.armor_expl.id], 0.76, places=3)
self.assertAlmostEqual(rah2.attrs[self.armor_em.id], 0.97, places=3)
self.assertAlmostEqual(rah2.attrs[self.armor_therm.id], 0.85, places=3)
self.assertAlmostEqual(rah2.attrs[self.armor_kin.id], 0.85, places=3)
self.assertAlmostEqual(rah2.attrs[self.armor_expl.id], 0.73, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.458, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_therm.id],
0.495,
places=3)
self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.535, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.52, places=3)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_multiple_with_nones(self):
# Make sure Nones are processed properly
self.fit.ship = Ship(self.mktype(attrs={AttrId.med_slots: 3}).id)
item_type = self.mktype()
item1 = ModuleMid(item_type.id)
item2 = ModuleMid(item_type.id)
item3 = ModuleMid(item_type.id)
self.fit.modules.mid.place(1, item1)
self.fit.modules.mid.place(4, item2)
self.fit.modules.mid.place(6, item3)
# Action
error1 = self.get_error(item1, Restriction.mid_slot)
# Verification
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.mid_slot)
# Verification
self.assertIsNotNone(error2)
self.assertEqual(error2.used, 7)
self.assertEqual(error2.total, 3)
# Action
error3 = self.get_error(item2, Restriction.mid_slot)
# Verification
self.assertIsNotNone(error3)
self.assertEqual(error3.used, 7)
self.assertEqual(error3.total, 3)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_order_em_therm_kin(self):
# Setup
self.fit.rah_incoming_dmg = DmgProfile(1, 1, 1, 0)
ship = Ship(self.make_ship_type((0.675, 0.675, 0.675, 0.675)).id)
self.fit.ship = ship
rah = ModuleLow(self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6,
1000).id,
state=State.active)
self.fit.modules.low.equip(rah)
# Verification
# From real tests, gecko vs gnosis with 2 explosive hardeners
# 0 0.850 0.850 0.850 0.850
# 1 0.910 0.790 0.790 0.910 (kin therm > em)
# 2 0.850 0.730 0.850 0.970 (therm > kin)
# ---loop---
# 3 0.805 0.790 0.805 1.000
# 4 0.775 0.850 0.775 1.000
# 5 0.835 0.820 0.745 1.000 (kin > em)
self.assertAlmostEqual(rah.attrs[self.armor_em.id], 0.805)
self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 0.82)
self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 0.775)
self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 1)
self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.543, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_therm.id],
0.553,
places=3)
self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.523, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.675, places=3)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_relay(self):
# Check that stats service relays wcehp stats properly
self.fit.ship = Ship(
self.mktype(
attrs={
AttrId.hp: 10,
AttrId.em_dmg_resonance: 0.8,
AttrId.therm_dmg_resonance: 0.5,
AttrId.kin_dmg_resonance: 0.5,
AttrId.expl_dmg_resonance: 0.5,
AttrId.armor_hp: 15,
AttrId.armor_em_dmg_resonance: 0.5,
AttrId.armor_therm_dmg_resonance: 0.8,
AttrId.armor_kin_dmg_resonance: 0.5,
AttrId.armor_expl_dmg_resonance: 0.5,
AttrId.shield_capacity: 20,
AttrId.shield_em_dmg_resonance: 0.5,
AttrId.shield_therm_dmg_resonance: 0.5,
AttrId.shield_kin_dmg_resonance: 0.65,
AttrId.shield_expl_dmg_resonance: 0.8
}).id)
# Action
worst_ehp_stats = self.fit.stats.worst_case_ehp
# Verification
self.assertAlmostEqual(worst_ehp_stats.hull, 12.5)
self.assertAlmostEqual(worst_ehp_stats.armor, 18.75)
self.assertAlmostEqual(worst_ehp_stats.shield, 25)
self.assertAlmostEqual(worst_ehp_stats.total, 56.25)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_multiple(self):
# When multiple consumers require less than calibration output alone,
# but in sum want more than total output, it should be erroneous
# situation
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.upgrade_capacity: 40
}).id)
item1 = Rig(
self.mktype(attrs={
AttrId.upgrade_cost: 25
}, effects=[self.effect]).id)
self.fit.rigs.add(item1)
item2 = Rig(
self.mktype(attrs={
AttrId.upgrade_cost: 20
}, effects=[self.effect]).id)
self.fit.rigs.add(item2)
# Action
error1 = self.get_error(item1, Restriction.calibration)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.output, 40)
self.assertEqual(error1.total_use, 45)
self.assertEqual(error1.item_use, 25)
# Action
error2 = self.get_error(item2, Restriction.calibration)
# Verification
self.assertIsNotNone(error2)
self.assertEqual(error2.output, 40)
self.assertEqual(error2.total_use, 45)
self.assertEqual(error2.item_use, 20)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_influence_single_item_running(self):
# Autocharge should be able to modify container when effect, which
# defines autocharge, is running
autocharge_modifier = self.mkmod_filter_item(ModDomain.ship)
autocharge_effect = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[autocharge_modifier])
autocharge_type = self.mktype(attrs={self.src_attr.id: 50},
effects=[autocharge_effect])
container_effect = self.mkeffect(effect_id=EffectId.target_attack,
category_id=EffectCategoryId.target)
container = ModuleHigh(self.mktype(attrs={
self.autocharge_attr_id:
autocharge_type.id
},
effects=[container_effect]).id,
state=State.active)
influence_tgt = Ship(self.mktype(attrs={self.tgt_attr.id: 10}).id)
self.fit.ship = influence_tgt
# Action
self.fit.modules.high.append(container)
# Verification
self.assertAlmostEqual(influence_tgt.attrs[self.tgt_attr.id], 15)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_output_ship_not_loaded(self):
self.fit.ship = Ship(self.allocate_type_id())
# Verification
self.assertAlmostEqual(self.fit.stats.powergrid.output, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_output(self):
self.fit.ship = Ship(self.mktype(attrs={AttrId.max_subsystems: 3}).id)
# Verification
self.assertEqual(self.fit.stats.subsystem_slots.total, 3)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_override_priority(self):
# Setup
ship = Ship(self.make_ship_type((0.5, 0.65, 0.75, 0.9)).id)
self.fit.ship = ship
rah = ModuleLow(
self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6, 1000).id,
state=State.online)
self.fit.modules.low.equip(rah)
# Calculate modified values
self.assertAlmostEqual(rah.attrs[self.armor_em.id], 0.85)
self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 0.85)
self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 0.85)
self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 0.85)
self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.5)
self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.65)
self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.75)
self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.9)
# Action
rah.state = State.active
# Verification
# Make sure override values are returned, even when modified values were
# stored
self.assertAlmostEqual(rah.attrs[self.armor_em.id], 1)
self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 0.925)
self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 0.82)
self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 0.655)
self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.5)
self.assertAlmostEqual(ship.attrs[self.armor_therm.id], 0.60125)
self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.615)
self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.5895)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_same_item(self):
# Real scenario - capital ships boost their agility via proxy attrs
# Setup
tgt_attr = self.mkattr()
src_attr1 = self.mkattr()
src_attr2 = self.mkattr()
modifier1 = self.make_modifier(src_attr1, tgt_attr)
modifier2 = self.make_modifier(src_attr2, tgt_attr)
effect1 = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier1])
effect2 = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier2])
item = Ship(
self.mktype(attrs={
src_attr1.id: 20,
src_attr2.id: 20,
tgt_attr.id: 100
},
effects=(effect1, effect2)).id)
# Action
self.fit.ship = item
# Verification
self.assertAlmostEqual(item.attrs[tgt_attr.id], 144)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_worst_em(self):
fit = Fit()
item = Ship(
self.mktype(
attrs={
AttrId.hp: 1,
AttrId.em_dmg_resonance: 0.8,
AttrId.therm_dmg_resonance: 0.7,
AttrId.kin_dmg_resonance: 0.7,
AttrId.expl_dmg_resonance: 0.7,
AttrId.armor_hp: 10,
AttrId.armor_em_dmg_resonance: 0.4,
AttrId.armor_therm_dmg_resonance: 0.3,
AttrId.armor_kin_dmg_resonance: 0.3,
AttrId.armor_expl_dmg_resonance: 0.3,
AttrId.shield_capacity: 100,
AttrId.shield_em_dmg_resonance: 0.2,
AttrId.shield_therm_dmg_resonance: 0.1,
AttrId.shield_kin_dmg_resonance: 0.1,
AttrId.shield_expl_dmg_resonance: 0.1
}).id)
fit.ship = item
# Verification
self.assertAlmostEqual(item.worst_case_ehp.hull, 1.25)
self.assertAlmostEqual(item.worst_case_ehp.armor, 25)
self.assertAlmostEqual(item.worst_case_ehp.shield, 500)
self.assertAlmostEqual(item.worst_case_ehp.total, 526.25)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_combination(self):
tgt_attr = self.mkattr()
src_attr = self.mkattr()
invalid_modifier = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=1972,
affectee_attr_id=tgt_attr.id,
operator=ModOperator.post_percent,
affector_attr_id=src_attr.id)
valid_modifier = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=tgt_attr.id,
operator=ModOperator.post_percent,
affector_attr_id=src_attr.id)
effect = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=(invalid_modifier, valid_modifier))
item_type = self.mktype(attrs={
src_attr.id: 20,
tgt_attr.id: 100
},
effects=[effect])
item = Ship(item_type.id)
# Action
self.fit.ship = item
# Verification
self.assertAlmostEqual(item.attrs[tgt_attr.id], 120)
self.assert_log_entries(2)
for log_record in self.log:
self.assertEqual(log_record.name, 'eos.calculator.affection')
self.assertEqual(log_record.levelno, logging.WARNING)
self.assertEqual(
log_record.msg, 'malformed modifier on item type {}: '
'unsupported affectee domain 1972'.format(item_type.id))
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
def test_fail_multiple(self):
# When multiple consumers require less than powergrid output alone, but
# in sum want more than total output, it should be erroneous situation
self.fit.ship = Ship(self.mktype(attrs={AttrId.power_output: 40}).id)
item1 = ModuleHigh(
self.mktype(attrs={AttrId.power: 25}, effects=[self.effect]).id,
state=State.online)
self.fit.modules.high.append(item1)
item2 = ModuleHigh(
self.mktype(attrs={AttrId.power: 20}, effects=[self.effect]).id,
state=State.online)
self.fit.modules.high.append(item2)
# Action
error1 = self.get_error(item1, Restriction.powergrid)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.output, 40)
self.assertEqual(error1.total_use, 45)
self.assertEqual(error1.item_use, 25)
# Action
error2 = self.get_error(item2, Restriction.powergrid)
# Verification
self.assertIsNotNone(error2)
self.assertEqual(error2.output, 40)
self.assertEqual(error2.total_use, 45)
self.assertEqual(error2.item_use, 20)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_generic(self):
fit = Fit()
item = Ship(self.mktype(attrs={
AttrId.em_dmg_resonance: 0.01,
AttrId.therm_dmg_resonance: 0.02,
AttrId.kin_dmg_resonance: 0.03,
AttrId.expl_dmg_resonance: 0.04,
AttrId.armor_em_dmg_resonance: 0.05,
AttrId.armor_therm_dmg_resonance: 0.06,
AttrId.armor_kin_dmg_resonance: 0.07,
AttrId.armor_expl_dmg_resonance: 0.08,
AttrId.shield_em_dmg_resonance: 0.09,
AttrId.shield_therm_dmg_resonance: 0.1,
AttrId.shield_kin_dmg_resonance: 0.11,
AttrId.shield_expl_dmg_resonance: 0.12}).id)
fit.ship = item
# Verification
self.assertAlmostEqual(item.resists.hull.em, 0.99)
self.assertAlmostEqual(item.resists.hull.thermal, 0.98)
self.assertAlmostEqual(item.resists.hull.kinetic, 0.97)
self.assertAlmostEqual(item.resists.hull.explosive, 0.96)
self.assertAlmostEqual(item.resists.armor.em, 0.95)
self.assertAlmostEqual(item.resists.armor.thermal, 0.94)
self.assertAlmostEqual(item.resists.armor.kinetic, 0.93)
self.assertAlmostEqual(item.resists.armor.explosive, 0.92)
self.assertAlmostEqual(item.resists.shield.em, 0.91)
self.assertAlmostEqual(item.resists.shield.thermal, 0.9)
self.assertAlmostEqual(item.resists.shield.kinetic, 0.89)
self.assertAlmostEqual(item.resists.shield.explosive, 0.88)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_fail_multiple(self):
# When multiple consumers require less than dronebay volume output
# alone, but in sum want more than total output, it should be erroneous
# situation
self.fit.ship = Ship(self.mktype(attrs={AttrId.drone_capacity: 40}).id)
item1 = Drone(self.mktype(attrs={AttrId.volume: 25}).id)
self.fit.drones.add(item1)
item2 = Drone(self.mktype(attrs={AttrId.volume: 20}).id)
self.fit.drones.add(item2)
# Action
error1 = self.get_error(item1, Restriction.dronebay_volume)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.output, 40)
self.assertEqual(error1.total_use, 45)
self.assertEqual(error1.item_use, 25)
# Action
error2 = self.get_error(item2, Restriction.dronebay_volume)
# Verification
self.assertIsNotNone(error2)
self.assertEqual(error2.output, 40)
self.assertEqual(error2.total_use, 45)
self.assertEqual(error2.item_use, 20)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_modified(self):
# Make sure modified calibration values are taken
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.upgrade_capacity: 50
}).id)
src_attr = self.mkattr()
modifier = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=AttrId.upgrade_cost,
operator=ModOperator.post_mul,
affector_attr_id=src_attr.id)
mod_effect = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier])
item = Rig(
self.mktype(attrs={
AttrId.upgrade_cost: 50,
src_attr.id: 2
},
effects=(self.effect, mod_effect)).id)
self.fit.rigs.add(item)
# Action
error = self.get_error(item, Restriction.calibration)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.output, 50)
self.assertEqual(error.total_use, 100)
self.assertEqual(error.item_use, 100)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_output_ship_not_loaded(self):
self.fit.ship = Ship(self.allocate_type_id())
# Verification
self.assertEqual(self.fit.stats.fighter_squads_light.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_mix_usage_zero(self):
# If some item has zero usage and calibration error is still raised,
# check it's not raised for item with zero usage
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.upgrade_capacity: 50
}).id)
item1 = Rig(
self.mktype(attrs={
AttrId.upgrade_cost: 100
},
effects=[self.effect]).id)
self.fit.rigs.add(item1)
item2 = Rig(
self.mktype(attrs={
AttrId.upgrade_cost: 0
}, effects=[self.effect]).id)
self.fit.rigs.add(item2)
# Action
error1 = self.get_error(item1, Restriction.calibration)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.output, 50)
self.assertEqual(error1.total_use, 100)
self.assertEqual(error1.item_use, 100)
# Action
error2 = self.get_error(item2, Restriction.calibration)
# Verification
self.assertIsNone(error2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_order_multi(self):
# Setup
ship = Ship(self.make_ship_type((0.675, 0.675, 0.675, 0.675)).id)
self.fit.ship = ship
rah = ModuleLow(self.make_rah_type((0.85, 0.85, 0.85, 0.85), 6,
1000).id,
state=State.active)
self.fit.modules.low.equip(rah)
# Verification
# From real tests, gecko vs gnosis
# ---loop---
# 0 0.850 0.850 0.850 0.850
# 1 0.910 0.790 0.790 0.910 (kin therm > em expl)
self.assertAlmostEqual(rah.attrs[self.armor_em.id], 0.88)
self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 0.82)
self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 0.82)
self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 0.88)
self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.594, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_therm.id],
0.554,
places=3)
self.assertAlmostEqual(ship.attrs[self.armor_kin.id], 0.554, places=3)
self.assertAlmostEqual(ship.attrs[self.armor_expl.id], 0.594, places=3)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_relay(self):
# Check that stats service relays resistance stats properly
self.fit.ship = Ship(self.mktype(attrs={
AttrId.em_dmg_resonance: 0.05,
AttrId.therm_dmg_resonance: 0.06,
AttrId.kin_dmg_resonance: 0.07,
AttrId.expl_dmg_resonance: 0.08,
AttrId.armor_em_dmg_resonance: 0.09,
AttrId.armor_therm_dmg_resonance: 0.1,
AttrId.armor_kin_dmg_resonance: 0.11,
AttrId.armor_expl_dmg_resonance: 0.12,
AttrId.shield_em_dmg_resonance: 0.13,
AttrId.shield_therm_dmg_resonance: 0.14,
AttrId.shield_kin_dmg_resonance: 0.15,
AttrId.shield_expl_dmg_resonance: 0.16}).id)
# Action
res_stats = self.fit.stats.resists
# Verification
self.assertAlmostEqual(res_stats.hull.em, 0.95)
self.assertAlmostEqual(res_stats.hull.thermal, 0.94)
self.assertAlmostEqual(res_stats.hull.kinetic, 0.93)
self.assertAlmostEqual(res_stats.hull.explosive, 0.92)
self.assertAlmostEqual(res_stats.armor.em, 0.91)
self.assertAlmostEqual(res_stats.armor.thermal, 0.9)
self.assertAlmostEqual(res_stats.armor.kinetic, 0.89)
self.assertAlmostEqual(res_stats.armor.explosive, 0.88)
self.assertAlmostEqual(res_stats.shield.em, 0.87)
self.assertAlmostEqual(res_stats.shield.thermal, 0.86)
self.assertAlmostEqual(res_stats.shield.kinetic, 0.85)
self.assertAlmostEqual(res_stats.shield.explosive, 0.84)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
