def test_switch_item(self):
# Here we create 2 separate fits with ships; each ship affects module
# with different strength. When we pass module from one fit to another,
# its internal attribute storage should be cleared. If it wasn't
# cleared, we wouldn't be able to get refreshed value of attribute
# Setup
src_attr_id = self.allocate_attr_id('src1', 'src2')
self.mkattr(src='src1', attr_id=src_attr_id)
self.mkattr(src='src2', attr_id=src_attr_id)
tgt_attr_id = self.allocate_attr_id('src1', 'src2')
self.mkattr(src='src1', attr_id=tgt_attr_id)
self.mkattr(src='src2', attr_id=tgt_attr_id)
modifier = self.mkmod(affectee_filter=ModAffecteeFilter.domain,
affectee_domain=ModDomain.ship,
affectee_attr_id=tgt_attr_id,
operator=ModOperator.post_percent,
affector_attr_id=src_attr_id)
effect_id = self.allocate_effect_id('src1', 'src2')
effect_src1 = self.mkeffect(src='src1',
effect_id=effect_id,
category_id=EffectCategoryId.passive,
modifiers=[modifier])
effect_src2 = self.mkeffect(src='src2',
effect_id=effect_id,
category_id=EffectCategoryId.passive,
modifiers=[modifier])
ship_type_id = self.allocate_type_id('src1', 'src2')
ship1 = Ship(
self.mktype(src='src1',
type_id=ship_type_id,
attrs={
src_attr_id: 10
},
effects=[effect_src1]).id)
ship2 = Ship(
self.mktype(src='src2',
type_id=ship_type_id,
attrs={
src_attr_id: 20
},
effects=[effect_src2]).id)
item_type_id = self.allocate_type_id('src1', 'src2')
self.mktype(src='src1', type_id=item_type_id, attrs={tgt_attr_id: 50})
self.mktype(src='src2', type_id=item_type_id, attrs={tgt_attr_id: 50})
item = Rig(item_type_id)
fit1 = Fit(SolarSystem('src1'))
fit1.ship = ship1
fit2 = Fit(SolarSystem('src2'))
fit2.ship = ship2
fit1.rigs.add(item)
self.assertAlmostEqual(item.attrs.get(tgt_attr_id), 55)
# Action
fit1.rigs.remove(item)
fit2.rigs.add(item)
# Verification
self.assertAlmostEqual(item.attrs.get(tgt_attr_id), 60)
# Cleanup
self.assert_solsys_buffers_empty(fit1.solar_system)
self.assert_solsys_buffers_empty(fit2.solar_system)
self.assert_log_entries(0)
def test_item_to_item(self):
fit = Fit()
ship_type = self.mktype()
item1 = Ship(ship_type.id)
item2 = Ship(ship_type.id)
fit.ship = item1
# Action
fit.ship = item2
# Verification
self.assertIs(fit.ship, item2)
# Cleanup
self.assert_item_buffers_empty(item1)
self.assert_item_buffers_empty(item2)
self.assert_solsys_buffers_empty(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_dmg_profile_rah_to_default(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.active)
self.fit.modules.low.equip(rah)
self.fit.rah_incoming_dmg = DmgProfile(1, 0, 0, 0)
# Force resonance calculation
self.assertAlmostEqual(rah.attrs[self.armor_em.id], 0.4)
self.assertAlmostEqual(rah.attrs[self.armor_therm.id], 1)
self.assertAlmostEqual(rah.attrs[self.armor_kin.id], 1)
self.assertAlmostEqual(rah.attrs[self.armor_expl.id], 1)
self.assertAlmostEqual(ship.attrs[self.armor_em.id], 0.2)
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
self.fit.rah_incoming_dmg = None
# Verification
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_relay(self):
# Check that stats service relays ehp stats properly
self.fit.ship = Ship(
self.mktype(
attrs={
AttrId.hp: 10,
AttrId.em_dmg_resonance: 0.5,
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.5,
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.5,
AttrId.shield_expl_dmg_resonance: 0.5
}).id)
# Action
ehp_stats = self.fit.stats.get_ehp(DmgProfile(1, 1, 1, 1))
# Verification
self.assertAlmostEqual(ehp_stats.hull, 20)
self.assertAlmostEqual(ehp_stats.armor, 30)
self.assertAlmostEqual(ehp_stats.shield, 40)
self.assertAlmostEqual(ehp_stats.total, 90)
# 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_pass(self):
# When total consumption is less than output, no errors should be raised
self.fit.ship = Ship(self.mktype(attrs={AttrId.power_output: 50}).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.assertIsNone(error1)
# 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_fail_modified(self):
# Make sure modified drone bandwidth values are taken
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.drone_bandwidth: 50
}).id)
src_attr = self.mkattr()
modifier = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=AttrId.drone_bandwidth_used,
operator=ModOperator.post_mul,
affector_attr_id=src_attr.id)
effect = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier])
item = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 50,
src_attr.id: 2
},
effects=[effect]).id,
state=State.online)
self.fit.drones.add(item)
# Action
error = self.get_error(item, Restriction.drone_bandwidth)
# 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_pass(self):
# When total consumption is less than output, no errors should be raised
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.drone_bandwidth: 50
}).id)
item1 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 25
}).id,
state=State.online)
self.fit.drones.add(item1)
item2 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 20
}).id,
state=State.online)
self.fit.drones.add(item2)
# Action
error1 = self.get_error(item1, Restriction.drone_bandwidth)
# Verification
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.drone_bandwidth)
# Verification
self.assertIsNone(error2)
# 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_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_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_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_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_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_output_ship_not_loaded(self):
self.fit.ship = Ship(self.allocate_type_id())
# Verification
self.assertAlmostEqual(self.fit.stats.dronebay.output, 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 drone bandwidth error is still raised,
# check it's not raised for item with zero usage
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.drone_bandwidth: 50
}).id)
item1 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 100
}).id,
state=State.online)
self.fit.drones.add(item1)
item2 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 0
}).id,
state=State.online)
self.fit.drones.add(item2)
# Action
error1 = self.get_error(item1, Restriction.drone_bandwidth)
# 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.drone_bandwidth)
# Verification
self.assertIsNone(error2)
# 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_fail_multiple(self):
# When multiple consumers require less than drone bandwidth output
# alone, but in sum want more than total output, it should be erroneous
# situation
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.drone_bandwidth: 40
}).id)
item1 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 25
}).id,
state=State.online)
self.fit.drones.add(item1)
item2 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 20
}).id,
state=State.online)
self.fit.drones.add(item2)
# Action
error1 = self.get_error(item1, Restriction.drone_bandwidth)
# 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.drone_bandwidth)
# 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_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_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_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_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_fail_multiple_with_nones(self):
# Make sure Nones are processed properly
self.fit.ship = Ship(self.mktype(attrs={AttrId.hi_slots: 3}).id)
item_type = self.mktype()
item1 = ModuleHigh(item_type.id)
item2 = ModuleHigh(item_type.id)
item3 = ModuleHigh(item_type.id)
self.fit.modules.high.place(1, item1)
self.fit.modules.high.place(4, item2)
self.fit.modules.high.place(6, item3)
# Action
error1 = self.get_error(item1, Restriction.high_slot)
# Verification
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.high_slot)
# Verification
self.assertIsNotNone(error2)
self.assertEqual(error2.used, 7)
self.assertEqual(error2.total, 3)
# Action
error3 = self.get_error(item2, Restriction.high_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_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_output_ship_attr_not_loaded(self):
self.fit.ship = Ship(self.allocate_type_id())
# Verification
self.assertEqual(self.fit.stats.mid_slots.total, 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.fighter_heavy_slots: 1
}).id)
item_type = self.mktype(attrs={AttrId.fighter_squadron_is_heavy: 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_heavy)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.used, 2)
self.assertEqual(error1.total, 1)
# Action
error2 = self.get_error(item2, Restriction.fighter_squad_heavy)
# 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_output_ship_attr_absent(self):
self.fit.ship = Ship(self.mktype().id)
# Verification
self.assertAlmostEqual(self.fit.stats.dronebay.output, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_rah_state_switch_up(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)
# Force resonance calculation
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
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_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)
