def test_status_item_inactive(self):
# Even when item is not set to active, ability statuses should be shown
# like item is active
# Setup
effect1 = self.mkeffect(
effect_id=EffectId.fighter_ability_attack_m,
category_id=EffectCategoryId.active)
effect2 = self.mkeffect(
effect_id=EffectId.fighter_ability_microwarpdrive,
category_id=EffectCategoryId.active)
effect3 = self.mkeffect(
effect_id=EffectId.fighter_ability_missiles,
category_id=EffectCategoryId.active)
fighter_type = self.mktype(
effects=(effect1, effect2, effect3),
default_effect=effect1,
abilities_data={
FighterAbilityId.pulse_cannon: AbilityData(0, math.inf),
FighterAbilityId.microwarpdrive: AbilityData(60, math.inf),
FighterAbilityId.heavy_rocket_salvo_em: AbilityData(0, 12)})
fit = Fit()
item = FighterSquad(fighter_type.id, state=State.online)
fit.fighters.add(item)
# Verification
abilities = item.abilities
self.assertEqual(len(abilities), 3)
self.assertIs(abilities[FighterAbilityId.pulse_cannon], True)
self.assertIs(abilities[FighterAbilityId.microwarpdrive], False)
self.assertIs(abilities[FighterAbilityId.heavy_rocket_salvo_em], False)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_ability_disabling_no_ability(self):
# Setup
src_attr = self.mkattr()
tgt_attr = self.mkattr()
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(
effect_id=EffectId.fighter_ability_attack_m,
category_id=EffectCategoryId.active,
modifiers=[modifier])
fighter_type = self.mktype(
attrs={src_attr.id: 50, tgt_attr.id: 10},
effects=[effect],
default_effect=effect,
abilities_data={
FighterAbilityId.pulse_cannon: AbilityData(0, math.inf)})
fit = Fit()
item = FighterSquad(fighter_type.id, state=State.active)
fit.fighters.add(item)
self.assertAlmostEqual(item.attrs[tgt_attr.id], 15)
# Verification
with self.assertRaises(NoSuchAbilityError):
item.set_ability_status(FighterAbilityId.beam_cannon, False)
self.assertIs(item.abilities[FighterAbilityId.pulse_cannon], True)
self.assertAlmostEqual(item.attrs[tgt_attr.id], 15)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_ability_charges_zero(self):
self.abilities_data = {FighterAbilityId.launch_bomb: AbilityData(0, 0)}
fit = Fit()
bomb_type = self.make_charge_type({
AttrId.em_dmg: 52,
AttrId.therm_dmg: 63,
AttrId.kin_dmg: 74,
AttrId.expl_dmg: 85
})
item = self.make_item({
AttrId.fighter_ability_launch_bomb_type:
bomb_type.id,
AttrId.fighter_squadron_max_size:
9
})
fit.fighters.add(item)
# Verification
volley = item.get_volley()
self.assertAlmostEqual(volley.em, 0)
self.assertAlmostEqual(volley.thermal, 0)
self.assertAlmostEqual(volley.kinetic, 0)
self.assertAlmostEqual(volley.explosive, 0)
self.assertAlmostEqual(volley.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def setUp(self):
StatsTestCase.setUp(self)
self.mkattr(attr_id=AttrId.em_dmg)
self.mkattr(attr_id=AttrId.therm_dmg)
self.mkattr(attr_id=AttrId.kin_dmg)
self.mkattr(attr_id=AttrId.expl_dmg)
self.mkattr(attr_id=AttrId.dmg_mult)
self.mkattr(attr_id=AttrId.volume)
self.mkattr(attr_id=AttrId.capacity)
self.mkattr(attr_id=AttrId.reload_time)
self.mkattr(attr_id=AttrId.charge_rate)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_em)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_therm)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_kin)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_expl)
cycle_attr = self.mkattr()
effect_dd = self.mkeffect(effect_id=EffectId.projectile_fired,
category_id=EffectCategoryId.active,
duration_attr_id=cycle_attr.id)
effect_suppressor = self.mkeffect(
effect_id=EffectId.fighter_ability_kamikaze,
category_id=EffectCategoryId.target,
duration_attr_id=cycle_attr.id)
item_dd = ModuleHigh(self.mktype(attrs={
AttrId.dmg_mult: 2,
AttrId.capacity: 1,
AttrId.charge_rate: 1,
cycle_attr.id: 2500,
AttrId.reload_time: 2000
},
effects=[effect_dd],
default_effect=effect_dd).id,
state=State.active)
item_dd.charge = Charge(
self.mktype(
attrs={
AttrId.volume: 1.0,
AttrId.em_dmg: 1.2,
AttrId.therm_dmg: 2.4,
AttrId.kin_dmg: 4.8,
AttrId.expl_dmg: 9.6
}).id)
self.item_suppressor = FighterSquad(self.mktype(
attrs={
AttrId.fighter_ability_kamikaze_dmg_em: 50000,
AttrId.fighter_ability_kamikaze_dmg_therm: 50000,
AttrId.fighter_ability_kamikaze_dmg_kin: 50000,
AttrId.fighter_ability_kamikaze_dmg_expl: 50000,
AttrId.fighter_squadron_max_size: 6,
cycle_attr.id: 10000
},
effects=[effect_suppressor],
default_effect=effect_suppressor,
abilities_data={
FighterAbilityId.kamikaze: AbilityData(0, math.inf)
}).id,
state=State.active)
self.fit.modules.high.append(item_dd)
self.fit.fighters.add(self.item_suppressor)
def setUp(self):
ItemMixinTestCase.setUp(self)
self.mkattr(attr_id=AttrId.em_dmg)
self.mkattr(attr_id=AttrId.therm_dmg)
self.mkattr(attr_id=AttrId.kin_dmg)
self.mkattr(attr_id=AttrId.expl_dmg)
self.mkattr(attr_id=AttrId.fighter_squadron_max_size)
self.effect_item = self.mkeffect(
effect_id=EffectId.fighter_ability_launch_bomb,
category_id=EffectCategoryId.active)
self.effect_charge = self.mkeffect(effect_id=EffectId.bomb_launching,
category_id=EffectCategoryId.active)
self.abilities_data = {FighterAbilityId.launch_bomb: AbilityData(0, 3)}
def setUp(self):
ItemMixinTestCase.setUp(self)
self.mkattr(attr_id=AttrId.fighter_ability_attack_missile_dmg_mult)
self.mkattr(attr_id=AttrId.fighter_ability_attack_missile_dmg_em)
self.mkattr(attr_id=AttrId.fighter_ability_attack_missile_dmg_therm)
self.mkattr(attr_id=AttrId.fighter_ability_attack_missile_dmg_kin)
self.mkattr(attr_id=AttrId.fighter_ability_attack_missile_dmg_expl)
self.mkattr(attr_id=AttrId.fighter_squadron_max_size)
self.effect = self.mkeffect(
effect_id=EffectId.fighter_ability_attack_m,
category_id=EffectCategoryId.target)
self.abilities_data = {
FighterAbilityId.pulse_cannon: AbilityData(0, math.inf)
}
def setUp(self):
ItemMixinTestCase.setUp(self)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_em)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_therm)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_kin)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_expl)
self.mkattr(attr_id=AttrId.fighter_squadron_max_size)
self.cycle_attr = self.mkattr()
self.effect = self.mkeffect(
effect_id=EffectId.fighter_ability_kamikaze,
category_id=EffectCategoryId.target,
duration_attr_id=self.cycle_attr.id)
self.abilities_data = {
FighterAbilityId.kamikaze: AbilityData(0, math.inf)}
def setUp(self):
ItemMixinTestCase.setUp(self)
self.mkattr(attr_id=AttrId.fighter_ability_missiles_dmg_mult)
self.mkattr(attr_id=AttrId.fighter_ability_missiles_dmg_em)
self.mkattr(attr_id=AttrId.fighter_ability_missiles_dmg_therm)
self.mkattr(attr_id=AttrId.fighter_ability_missiles_dmg_kin)
self.mkattr(attr_id=AttrId.fighter_ability_missiles_dmg_expl)
self.mkattr(attr_id=AttrId.fighter_squadron_max_size)
self.cycle_attr = self.mkattr()
self.effect = self.mkeffect(
effect_id=EffectId.fighter_ability_missiles,
category_id=EffectCategoryId.target,
duration_attr_id=self.cycle_attr.id)
self.abilities_data = {
FighterAbilityId.heavy_rocket_salvo_em: AbilityData(0, 12)}
def __type_decompress(self, type_data):
"""Reconstruct item type from python primitives."""
default_effect_id = type_data[5]
if default_effect_id is None:
default_effect = None
else:
default_effect = self.get_effect(default_effect_id)
return TypeFactory.make(
type_id=type_data[0],
group_id=type_data[1],
category_id=type_data[2],
attrs={k: v
for k, v in type_data[3]},
effects=tuple(self.get_effect(eid) for eid in type_data[4]),
default_effect=default_effect,
abilities_data={k: AbilityData(*v)
for k, v in type_data[6]})
def test_ability_charges_zero(self):
self.abilities_data = {
FighterAbilityId.heavy_rocket_salvo_em: AbilityData(0, 0)}
fit = Fit()
item = self.make_item({
AttrId.fighter_ability_attack_missile_dmg_mult: 2.5,
AttrId.fighter_ability_attack_missile_dmg_em: 52,
AttrId.fighter_ability_attack_missile_dmg_therm: 63,
AttrId.fighter_ability_attack_missile_dmg_kin: 74,
AttrId.fighter_ability_attack_missile_dmg_expl: 85,
AttrId.fighter_squadron_max_size: 9})
fit.fighters.add(item)
# Verification
volley = item.get_volley()
self.assertAlmostEqual(volley.em, 0)
self.assertAlmostEqual(volley.thermal, 0)
self.assertAlmostEqual(volley.kinetic, 0)
self.assertAlmostEqual(volley.explosive, 0)
self.assertAlmostEqual(volley.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def run(data):
"""Convert data into eve objects.
Args:
data: Dictionary in {table name: {table, rows}} format.
Returns:
3 iterables, which contain types, attributes and effects.
"""
# Before actually instantiating anything, we need to collect some data
# in convenient form
# Format: {group ID: group row}
groups_keyed = {}
for row in data['evegroups']:
groups_keyed[row['groupID']] = row
# Format: {type ID: default effect ID}
types_defeff_map = {}
for row in data['dgmtypeeffects']:
if row.get('isDefault') is True:
types_defeff_map[row['typeID']] = row['effectID']
# Format: {type ID: {effect IDs}}
types_effects = {}
for row in data['dgmtypeeffects']:
types_effects.setdefault(row['typeID'], set()).add(row['effectID'])
# Format: {type ID: {attribute ID: value}}
types_attrs = {}
for row in data['dgmtypeattribs']:
type_attrs = types_attrs.setdefault(row['typeID'], {})
type_attrs[row['attributeID']] = row['value']
# Format: {type ID: {ability ID: (cooldown, charge quantity)}}
types_abilities_data = {}
for row in data['typefighterabils']:
type_id = row['typeID']
type_abilities_data = types_abilities_data.setdefault(type_id, {})
type_abilities_data[row['abilityID']] = AbilityData(
cooldown_time=row.get('cooldownSeconds', 0),
charge_quantity=row.get('chargeCount', math.inf))
# Convert attributes
attrs = []
for row in data['dgmattribs']:
attrs.append(
Attribute(attr_id=row['attributeID'],
max_attr_id=row.get('maxAttributeID'),
default_value=row.get('defaultValue'),
high_is_good=row.get('highIsGood'),
stackable=row.get('stackable')))
# Convert effects
effects = []
mod_builder = ModBuilder(data['dgmexpressions'])
for row in data['dgmeffects']:
modifiers, build_status = mod_builder.build(row)
effects.append(
Effect(
effect_id=row['effectID'],
category_id=row.get('effectCategory'),
is_offensive=row.get('isOffensive'),
is_assistance=row.get('isAssistance'),
duration_attr_id=row.get('durationAttributeID'),
discharge_attr_id=row.get('dischargeAttributeID'),
range_attr_id=row.get('rangeAttributeID'),
falloff_attr_id=row.get('falloffAttributeID'),
tracking_speed_attr_id=row.get('trackingSpeedAttributeID'),
fitting_usage_chance_attr_id=(
row.get('fittingUsageChanceAttributeID')),
resist_attr_id=row.get('resistanceID'),
build_status=build_status,
modifiers=tuple(modifiers)))
# Convert types
types = []
effect_map = {e.id: e for e in effects}
for row in data['evetypes']:
type_id = row['typeID']
type_group = row.get('groupID')
type_effect_ids = types_effects.get(type_id, set())
type_effect_ids.intersection_update(effect_map)
types.append(
Type(type_id=type_id,
group_id=type_group,
category_id=groups_keyed.get(type_group,
{}).get('categoryID'),
attrs=types_attrs.get(type_id, {}),
effects=tuple(effect_map[eid] for eid in type_effect_ids),
default_effect=effect_map.get(
types_defeff_map.get(type_id)),
abilities_data=types_abilities_data.get(type_id, {})))
return types, attrs, effects