def setUp(self): super().setUp() self.tgt_attr = self.ch.attribute(attribute_id=1) src_attr = self.ch.attribute(attribute_id=2) modifier = Modifier() modifier.state = State.offline modifier.scope = Scope.local modifier.src_attr = src_attr.id modifier.operator = Operator.mod_sub modifier.tgt_attr = self.tgt_attr.id modifier.domain = Domain.ship modifier.filter_type = FilterType.all_ modifier.filter_value = None effect = self.ch.effect(effect_id=1, category=EffectCategory.passive) effect.modifiers = (modifier, ) self.influence_source1 = IndependentItem( self.ch.type_(type_id=1, effects=(effect, ), attributes={src_attr.id: -10})) self.influence_source2 = IndependentItem( self.ch.type_(type_id=2, effects=(effect, ), attributes={src_attr.id: 20})) self.influence_source3 = IndependentItem( self.ch.type_(type_id=3, effects=(effect, ), attributes={src_attr.id: -53})) self.influence_target = ShipItem( self.ch.type_(type_id=4, attributes={self.tgt_attr.id: 100})) self.fit.items.add(self.influence_source1) self.fit.items.add(self.influence_source2) self.fit.items.add(self.influence_source3) self.fit.items.add(self.influence_target)
def test_other_group(self): influence_target = ShipItem(self.ch.type_(type_id=2, group=3, attributes={self.tgt_attr.id: 100})) self.fit.items.add(influence_target) self.assertAlmostEqual(influence_target.attributes[self.tgt_attr.id], 100) self.fit.items.remove(self.influence_source) self.fit.items.remove(influence_target) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_other_skill(self): item = self.ch.type_(type_id=1, attributes={self.tgt_attr.id: 100}) item.required_skills = {51: 1} influence_target = ShipItem(item) self.fit.items.add(influence_target) self.assertAlmostEqual(influence_target.attributes[self.tgt_attr.id], 100) self.fit.items.remove(self.influence_source) self.fit.items.remove(influence_target) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_ship(self): self.fit.ship = self.influence_source influence_target = ShipItem(self.ch.type_(type_id=1, attributes={self.tgt_attr.id: 100})) self.fit.items.add(influence_target) self.assertNotAlmostEqual(influence_target.attributes[self.tgt_attr.id], 100) self.fit.ship = None self.assertAlmostEqual(influence_target.attributes[self.tgt_attr.id], 100) self.fit.items.remove(influence_target) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_ship(self): holder = ShipItem( self.ch.type_(type_id=1, effects=(self.effect, ), attributes={ self.tgt_attr.id: 100, self.src_attr.id: 20 })) self.fit.items.add(holder) self.assertNotAlmostEqual(holder.attributes[self.tgt_attr.id], 100) self.fit.items.remove(holder) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_attribute(self): attr1 = self.ch.attribute(attribute_id=1) attr2 = self.ch.attribute(attribute_id=2) attr3 = self.ch.attribute(attribute_id=3) modifier1 = Modifier() modifier1.state = State.offline modifier1.scope = Scope.local modifier1.src_attr = attr1.id modifier1.operator = Operator.post_mul modifier1.tgt_attr = attr2.id modifier1.domain = Domain.ship modifier1.filter_type = None modifier1.filter_value = None effect1 = self.ch.effect(effect_id=1, category=EffectCategory.passive) effect1.modifiers = (modifier1, ) holder1 = CharacterItem( self.ch.type_(type_id=1, effects=(effect1, ), attributes={attr1.id: 5})) modifier2 = Modifier() modifier2.state = State.offline modifier2.scope = Scope.local modifier2.src_attr = attr2.id modifier2.operator = Operator.post_percent modifier2.tgt_attr = attr3.id modifier2.domain = Domain.ship modifier2.filter_type = FilterType.all_ modifier2.filter_value = None effect2 = self.ch.effect(effect_id=2, category=EffectCategory.passive) effect2.modifiers = (modifier2, ) holder2 = IndependentItem( self.ch.type_(type_id=2, effects=(effect2, ), attributes={attr2.id: 7.5})) holder3 = ShipItem(self.ch.type_(type_id=3, attributes={attr3.id: 0.5})) self.fit.items.add(holder1) self.fit.ship = holder2 self.fit.items.add(holder3) self.assertAlmostEqual(holder3.attributes[attr3.id], 0.6875) holder1.attributes[attr1.id] = 4 # Manually changed attribute must trigger damaging whole chain # of attributes, effectively allowing us to recalculate its new value self.assertAlmostEqual(holder3.attributes[attr3.id], 0.65) self.fit.items.remove(holder1) self.fit.ship = None self.fit.items.remove(holder3) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_implant(self): influence_source1 = IndependentItem(self.ch.type_( type_id=1, effects=(self.effect,), category=Category.implant, attributes={self.src_attr.id: 50})) influence_source2 = IndependentItem(self.ch.type_( type_id=2, effects=(self.effect,), category=Category.implant, attributes={self.src_attr.id: 100})) self.fit.items.add(influence_source1) self.fit.items.add(influence_source2) influence_target = ShipItem(self.ch.type_(type_id=3, attributes={self.tgt_attr.id: 100})) self.fit.items.add(influence_target) self.assertAlmostEqual(influence_target.attributes[self.tgt_attr.id], 300) self.fit.items.remove(influence_source1) self.fit.items.remove(influence_source2) self.fit.items.remove(influence_target) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_attribute(self): attr1 = self.ch.attribute(attribute_id=1) attr2 = self.ch.attribute(attribute_id=2) attr3 = self.ch.attribute(attribute_id=3) modifier1 = Modifier() modifier1.state = State.offline modifier1.scope = Scope.local modifier1.src_attr = attr1.id modifier1.operator = Operator.post_mul modifier1.tgt_attr = attr2.id modifier1.domain = Domain.ship modifier1.filter_type = None modifier1.filter_value = None effect1 = self.ch.effect(effect_id=1, category=EffectCategory.passive) effect1.modifiers = (modifier1, ) holder1 = CharacterItem( self.ch.type_(type_id=1, effects=(effect1, ), attributes={attr1.id: 5})) modifier2 = Modifier() modifier2.state = State.offline modifier2.scope = Scope.local modifier2.src_attr = attr2.id modifier2.operator = Operator.post_percent modifier2.tgt_attr = attr3.id modifier2.domain = Domain.ship modifier2.filter_type = FilterType.all_ modifier2.filter_value = None effect2 = self.ch.effect(effect_id=2, category=EffectCategory.passive) effect2.modifiers = (modifier2, ) holder2 = IndependentItem( self.ch.type_(type_id=2, effects=(effect2, ), attributes={attr2.id: 7.5})) holder3 = ShipItem(self.ch.type_(type_id=3, attributes={attr3.id: 0.5})) self.fit.items.add(holder1) self.fit.ship = holder2 self.fit.items.add(holder3) self.assertAlmostEqual(holder3.attributes[attr3.id], 0.6875) self.fit.items.remove(holder1) # When holder1 is removed, attr2 of holder2 and attr3 of holder3 # must be cleaned to allow recalculation of attr3 based on new data self.assertAlmostEqual(holder3.attributes[attr3.id], 0.5375) self.fit.ship = None self.fit.items.remove(holder3) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_fit_attr_update(self): # Here we create 2 separate fits with ships affecting it; # 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 src_attr = self.ch.attribute(attribute_id=1) tgt_attr = self.ch.attribute(attribute_id=2) modifier = Modifier() modifier.state = State.offline modifier.scope = Scope.local modifier.src_attr = src_attr.id modifier.operator = Operator.post_percent modifier.tgt_attr = tgt_attr.id modifier.domain = Domain.ship modifier.filter_type = FilterType.all_ modifier.filter_value = None effect = self.ch.effect(effect_id=1, category=EffectCategory.passive) effect.modifiers = (modifier, ) ship1 = IndependentItem( self.ch.type_(type_id=1, effects=(effect, ), attributes={src_attr.id: 10})) ship2 = IndependentItem( self.ch.type_(type_id=2, effects=(effect, ), attributes={src_attr.id: 20})) module = ShipItem( self.ch.type_(type_id=3, attributes={tgt_attr.id: 50})) fit1 = Fit(self.ch) fit1.ship = ship1 fit2 = Fit(self.ch) fit2.ship = ship2 fit1.items.add(module) self.assertAlmostEqual(module.attributes.get(tgt_attr.id), 55) fit1.items.remove(module) fit1.ship = None self.assert_link_buffers_empty(fit1) fit2.items.add(module) self.assertAlmostEqual(module.attributes.get(tgt_attr.id), 60) fit2.ship = None fit2.items.remove(module) self.assert_link_buffers_empty(fit2)
def test_combination(self): valid_modifier = Modifier() valid_modifier.state = State.offline valid_modifier.scope = Scope.local valid_modifier.src_attr = self.src_attr.id valid_modifier.operator = Operator.post_percent valid_modifier.tgt_attr = self.tgt_attr.id valid_modifier.domain = Domain.ship valid_modifier.filter_type = FilterType.all_ valid_modifier.filter_value = None self.effect.modifiers = (self.invalid_modifier, valid_modifier) influence_source = IndependentItem(self.ch.type_( type_id=1, effects=(self.effect,), attributes={self.src_attr.id: 20})) self.fit.items.add(influence_source) influence_target = ShipItem(self.ch.type_(type_id=2, attributes={self.tgt_attr.id: 100})) self.fit.items.add(influence_target) # Invalid domain in modifier should prevent proper processing of other modifiers self.assertNotAlmostEqual(influence_target.attributes[self.tgt_attr.id], 100) self.fit.items.remove(influence_target) self.fit.items.remove(influence_source) self.assertEqual(len(self.log), 5) self.assert_link_buffers_empty(self.fit)
def test_cap_update(self): # If cap updates, capped attributes should # be updated too holder = ShipItem( self.ch.type_(type_id=1, effects=(self.effect, ), attributes={ self.capped_attr.id: 3, self.source_attr.id: 6, self.capping_attr.id: 2 })) self.fit.items.add(holder) # Check attribute vs original cap self.assertAlmostEqual(holder.attributes[self.capped_attr.id], 2) # Add something which changes capping attribute modifier = Modifier() modifier.state = State.offline modifier.scope = Scope.local modifier.src_attr = self.source_attr.id modifier.operator = Operator.post_mul modifier.tgt_attr = self.capping_attr.id modifier.domain = Domain.ship modifier.filter_type = FilterType.all_ modifier.filter_value = None effect = self.ch.effect(effect_id=2, category=EffectCategory.passive) effect.modifiers = (modifier, ) cap_updater = IndependentItem( self.ch.type_(type_id=2, effects=(effect, ), attributes={self.source_attr.id: 3.5})) self.fit.items.add(cap_updater) # As capping attribute is updated, capped attribute must be updated too self.assertAlmostEqual(holder.attributes[self.capped_attr.id], 7) self.fit.items.remove(holder) self.fit.items.remove(cap_updater) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_source_attr_update(self): # Here we check if attributes are updated if fit gets new # source instance; we do not actually switch source but we # switch cache_handler, and it should be enough cache_handler1 = CacheHandler() cache_handler2 = CacheHandler() src_attr1 = cache_handler1.attribute(attribute_id=1) tgt_attr1 = cache_handler1.attribute(attribute_id=2, max_attribute=33) cache_handler1.attribute(attribute_id=33, default_value=100) src_attr2 = cache_handler2.attribute(attribute_id=1) tgt_attr2 = cache_handler2.attribute(attribute_id=2, max_attribute=333) cache_handler2.attribute(attribute_id=333, default_value=500) modifier = Modifier() modifier.state = State.offline modifier.scope = Scope.local modifier.src_attr = 1 modifier.operator = Operator.post_percent modifier.tgt_attr = 2 modifier.domain = Domain.ship modifier.filter_type = FilterType.all_ modifier.filter_value = None effect1 = cache_handler1.effect(effect_id=1, category=EffectCategory.passive) effect1.modifiers = (modifier, ) effect2 = cache_handler1.effect(effect_id=111, category=EffectCategory.passive) effect2.modifiers = (modifier, ) # Our holders from test environment fo not update undelying # item automatically when source is changed, thus we do it # manually ship_item1 = cache_handler1.type_(type_id=8, effects=(effect1, ), attributes={src_attr1.id: 10}) ship_item2 = cache_handler2.type_(type_id=8, effects=(effect2, ), attributes={src_attr2.id: 20}) module_item1 = cache_handler1.type_(type_id=4, attributes={tgt_attr1.id: 50}) module_item2 = cache_handler2.type_(type_id=4, attributes={tgt_attr2.id: 75}) fit = Fit(cache_handler1) ship = IndependentItem(ship_item1) module = ShipItem(module_item1) fit.ship = ship fit.items.add(module) self.assertAlmostEqual(module.attributes.get(tgt_attr1.id), 55) # As we have capped attr, this auxiliary map shouldn't be None self.assertIsNotNone(module.attributes._cap_map) # Make an 'source switch': remove holders from attribute_calculator for holder in (ship, module): disabled_states = set(filter(lambda s: s <= holder.state, State)) fit._link_tracker.disable_states(holder, disabled_states) fit._link_tracker.remove_holder(holder) # Refresh holders and replace source fit.source.cache_handler = cache_handler2 ship.attributes.clear() ship.item = ship_item2 module.attributes.clear() module.item = module_item2 # When we cleared holders, auxiliary map for capped attrs should be None. # Using data in this map, attributes which depend on capping attribute will # be cleared. If we don't clear it, there're chances that in new data this # capping-capped attribute pair won't exist, thus if attribute with ID which # used to cap is changed, it will clear attribute which used to be capped - # and we do not want it within scope of new data. self.assertIsNone(module.attributes._cap_map) # Add holders again, when new items are in holders for holder in (ship, module): fit._link_tracker.add_holder(holder) enabled_states = set(filter(lambda s: s <= holder.state, State)) fit._link_tracker.enable_states(holder, enabled_states) # Now we should have calculated value based on both updated attribs # if attribs weren't refreshed, we would use old value for modification # (10 instead of 20) self.assertAlmostEqual(module.attributes.get(tgt_attr2.id), 90) fit.ship = None fit.items.remove(module) self.assert_link_buffers_empty(fit)
def test_forced_value(self): tgt_attr = self.ch.attribute(attribute_id=1) src_attr = self.ch.attribute(attribute_id=2) modifier_pre_ass = Modifier() modifier_pre_ass.state = State.offline modifier_pre_ass.scope = Scope.local modifier_pre_ass.src_attr = src_attr.id modifier_pre_ass.operator = Operator.pre_assign modifier_pre_ass.tgt_attr = tgt_attr.id modifier_pre_ass.domain = Domain.ship modifier_pre_ass.filter_type = FilterType.all_ modifier_pre_ass.filter_value = None effect_pre_ass = self.ch.effect(effect_id=1, category=EffectCategory.passive) effect_pre_ass.modifiers = (modifier_pre_ass,) influence_source_pre_ass = IndependentItem(self.ch.type_( type_id=1, effects=(effect_pre_ass,), attributes={src_attr.id: 5})) self.fit.items.add(influence_source_pre_ass) modifier_pre_mul = Modifier() modifier_pre_mul.state = State.offline modifier_pre_mul.scope = Scope.local modifier_pre_mul.src_attr = src_attr.id modifier_pre_mul.operator = Operator.pre_mul modifier_pre_mul.tgt_attr = tgt_attr.id modifier_pre_mul.domain = Domain.ship modifier_pre_mul.filter_type = FilterType.all_ modifier_pre_mul.filter_value = None effect_pre_mul = self.ch.effect(effect_id=2, category=EffectCategory.passive) effect_pre_mul.modifiers = (modifier_pre_mul,) influence_source_pre_mul = IndependentItem(self.ch.type_( type_id=2, effects=(effect_pre_mul,), attributes={src_attr.id: 50})) self.fit.items.add(influence_source_pre_mul) modifier_pre_div = Modifier() modifier_pre_div.state = State.offline modifier_pre_div.scope = Scope.local modifier_pre_div.src_attr = src_attr.id modifier_pre_div.operator = Operator.pre_div modifier_pre_div.tgt_attr = tgt_attr.id modifier_pre_div.domain = Domain.ship modifier_pre_div.filter_type = FilterType.all_ modifier_pre_div.filter_value = None effect_pre_div = self.ch.effect(effect_id=3, category=EffectCategory.passive) effect_pre_div.modifiers = (modifier_pre_div,) influence_source_pre_div = IndependentItem(self.ch.type_( type_id=3, effects=(effect_pre_div,), attributes={src_attr.id: 0.5})) self.fit.items.add(influence_source_pre_div) modifier_mod_add = Modifier() modifier_mod_add.state = State.offline modifier_mod_add.scope = Scope.local modifier_mod_add.src_attr = src_attr.id modifier_mod_add.operator = Operator.mod_add modifier_mod_add.tgt_attr = tgt_attr.id modifier_mod_add.domain = Domain.ship modifier_mod_add.filter_type = FilterType.all_ modifier_mod_add.filter_value = None effect_mod_add = self.ch.effect(effect_id=4, category=EffectCategory.passive) effect_mod_add.modifiers = (modifier_mod_add,) influence_source_mod_add = IndependentItem(self.ch.type_( type_id=4, effects=(effect_mod_add,), attributes={src_attr.id: 10})) self.fit.items.add(influence_source_mod_add) modifier_mod_sub = Modifier() modifier_mod_sub.state = State.offline modifier_mod_sub.scope = Scope.local modifier_mod_sub.src_attr = src_attr.id modifier_mod_sub.operator = Operator.mod_sub modifier_mod_sub.tgt_attr = tgt_attr.id modifier_mod_sub.domain = Domain.ship modifier_mod_sub.filter_type = FilterType.all_ modifier_mod_sub.filter_value = None effect_mod_sub = self.ch.effect(effect_id=5, category=EffectCategory.passive) effect_mod_sub.modifiers = (modifier_mod_sub,) influence_source_mod_sub = IndependentItem(self.ch.type_( type_id=5, effects=(effect_mod_sub,), attributes={src_attr.id: 63})) self.fit.items.add(influence_source_mod_sub) modifier_post_mul = Modifier() modifier_post_mul.state = State.offline modifier_post_mul.scope = Scope.local modifier_post_mul.src_attr = src_attr.id modifier_post_mul.operator = Operator.post_mul modifier_post_mul.tgt_attr = tgt_attr.id modifier_post_mul.domain = Domain.ship modifier_post_mul.filter_type = FilterType.all_ modifier_post_mul.filter_value = None effect_post_mul = self.ch.effect(effect_id=6, category=EffectCategory.passive) effect_post_mul.modifiers = (modifier_post_mul,) influence_source_post_mul = IndependentItem(self.ch.type_( type_id=6, effects=(effect_post_mul,), attributes={src_attr.id: 1.35})) self.fit.items.add(influence_source_post_mul) modifier_post_div = Modifier() modifier_post_div.state = State.offline modifier_post_div.scope = Scope.local modifier_post_div.src_attr = src_attr.id modifier_post_div.operator = Operator.post_div modifier_post_div.tgt_attr = tgt_attr.id modifier_post_div.domain = Domain.ship modifier_post_div.filter_type = FilterType.all_ modifier_post_div.filter_value = None effect_post_div = self.ch.effect(effect_id=7, category=EffectCategory.passive) effect_post_div.modifiers = (modifier_post_div,) influence_source_post_div = IndependentItem(self.ch.type_( type_id=7, effects=(effect_post_div,), attributes={src_attr.id: 2.7})) self.fit.items.add(influence_source_post_div) modifier_post_perc = Modifier() modifier_post_perc.state = State.offline modifier_post_perc.scope = Scope.local modifier_post_perc.src_attr = src_attr.id modifier_post_perc.operator = Operator.post_percent modifier_post_perc.tgt_attr = tgt_attr.id modifier_post_perc.domain = Domain.ship modifier_post_perc.filter_type = FilterType.all_ modifier_post_perc.filter_value = None effect_post_perc = self.ch.effect(effect_id=8, category=EffectCategory.passive) effect_post_perc.modifiers = (modifier_post_perc,) influence_source_post_perc = IndependentItem(self.ch.type_( type_id=8, effects=(effect_post_perc,), attributes={src_attr.id: 15})) self.fit.items.add(influence_source_post_perc) modifier_post_ass = Modifier() modifier_post_ass.state = State.offline modifier_post_ass.scope = Scope.local modifier_post_ass.src_attr = src_attr.id modifier_post_ass.operator = Operator.post_assign modifier_post_ass.tgt_attr = tgt_attr.id modifier_post_ass.domain = Domain.ship modifier_post_ass.filter_type = FilterType.all_ modifier_post_ass.filter_value = None effect_post_ass = self.ch.effect(effect_id=9, category=EffectCategory.passive) effect_post_ass.modifiers = (modifier_post_ass,) influence_source_post_ass = IndependentItem(self.ch.type_( type_id=9, effects=(effect_post_ass,), attributes={src_attr.id: 68})) self.fit.items.add(influence_source_post_ass) influence_target = ShipItem(self.ch.type_(type_id=10, attributes={tgt_attr.id: 100})) self.fit.items.add(influence_target) # Post-assignment value must override all other modifications self.assertAlmostEqual(influence_target.attributes[tgt_attr.id], 68) self.fit.items.remove(influence_source_pre_ass) self.fit.items.remove(influence_source_pre_mul) self.fit.items.remove(influence_source_pre_div) self.fit.items.remove(influence_source_mod_add) self.fit.items.remove(influence_source_mod_sub) self.fit.items.remove(influence_source_post_mul) self.fit.items.remove(influence_source_post_div) self.fit.items.remove(influence_source_post_perc) self.fit.items.remove(influence_source_post_ass) self.fit.items.remove(influence_target) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_attribute_access(self): type_ = self.ch.type_(type_id=1, attributes={56: 50}) module = ShipItem(type_) attr_value = module.attributes[56] self.assertEqual(attr_value, 50) self.assertEqual(len(self.log), 0)
def test_all_in(self): tgt_attr = self.ch.attribute(attribute_id=1, stackable=0) src_attr = self.ch.attribute(attribute_id=2) modifier_pre_ass = Modifier() modifier_pre_ass.state = State.offline modifier_pre_ass.scope = Scope.local modifier_pre_ass.src_attr = src_attr.id modifier_pre_ass.operator = Operator.pre_assign modifier_pre_ass.tgt_attr = tgt_attr.id modifier_pre_ass.domain = Domain.ship modifier_pre_ass.filter_type = FilterType.all_ modifier_pre_ass.filter_value = None effect_pre_ass = self.ch.effect(effect_id=1, category=EffectCategory.passive) effect_pre_ass.modifiers = (modifier_pre_ass, ) value_pre_ass = 5 influence_source_pre_ass = IndependentItem( self.ch.type_(type_id=1, effects=(effect_pre_ass, ), attributes={src_attr.id: value_pre_ass})) self.fit.items.add(influence_source_pre_ass) modifier_pre_mul = Modifier() modifier_pre_mul.state = State.offline modifier_pre_mul.scope = Scope.local modifier_pre_mul.src_attr = src_attr.id modifier_pre_mul.operator = Operator.pre_mul modifier_pre_mul.tgt_attr = tgt_attr.id modifier_pre_mul.domain = Domain.ship modifier_pre_mul.filter_type = FilterType.all_ modifier_pre_mul.filter_value = None effect_pre_mul = self.ch.effect(effect_id=2, category=EffectCategory.passive) effect_pre_mul.modifiers = (modifier_pre_mul, ) value_pre_mul = 50 influence_source_pre_mul = IndependentItem( self.ch.type_(type_id=2, effects=(effect_pre_mul, ), attributes={src_attr.id: value_pre_mul})) self.fit.items.add(influence_source_pre_mul) modifier_pre_div = Modifier() modifier_pre_div.state = State.offline modifier_pre_div.scope = Scope.local modifier_pre_div.src_attr = src_attr.id modifier_pre_div.operator = Operator.pre_div modifier_pre_div.tgt_attr = tgt_attr.id modifier_pre_div.domain = Domain.ship modifier_pre_div.filter_type = FilterType.all_ modifier_pre_div.filter_value = None effect_pre_div = self.ch.effect(effect_id=3, category=EffectCategory.passive) effect_pre_div.modifiers = (modifier_pre_div, ) value_pre_div = 0.5 influence_source_pre_div = IndependentItem( self.ch.type_(type_id=3, effects=(effect_pre_div, ), attributes={src_attr.id: value_pre_div})) self.fit.items.add(influence_source_pre_div) modifier_mod_add = Modifier() modifier_mod_add.state = State.offline modifier_mod_add.scope = Scope.local modifier_mod_add.src_attr = src_attr.id modifier_mod_add.operator = Operator.mod_add modifier_mod_add.tgt_attr = tgt_attr.id modifier_mod_add.domain = Domain.ship modifier_mod_add.filter_type = FilterType.all_ modifier_mod_add.filter_value = None effect_mod_add = self.ch.effect(effect_id=4, category=EffectCategory.passive) effect_mod_add.modifiers = (modifier_mod_add, ) value_mod_add = 10 influence_source_mod_add = IndependentItem( self.ch.type_(type_id=4, effects=(effect_mod_add, ), attributes={src_attr.id: value_mod_add})) self.fit.items.add(influence_source_mod_add) modifier_mod_sub = Modifier() modifier_mod_sub.state = State.offline modifier_mod_sub.scope = Scope.local modifier_mod_sub.src_attr = src_attr.id modifier_mod_sub.operator = Operator.mod_sub modifier_mod_sub.tgt_attr = tgt_attr.id modifier_mod_sub.domain = Domain.ship modifier_mod_sub.filter_type = FilterType.all_ modifier_mod_sub.filter_value = None effect_mod_sub = self.ch.effect(effect_id=5, category=EffectCategory.passive) effect_mod_sub.modifiers = (modifier_mod_sub, ) value_mod_sub = 63 influence_source_mod_sub = IndependentItem( self.ch.type_(type_id=5, effects=(effect_mod_sub, ), attributes={src_attr.id: value_mod_sub})) self.fit.items.add(influence_source_mod_sub) modifier_post_mul = Modifier() modifier_post_mul.state = State.offline modifier_post_mul.scope = Scope.local modifier_post_mul.src_attr = src_attr.id modifier_post_mul.operator = Operator.post_mul modifier_post_mul.tgt_attr = tgt_attr.id modifier_post_mul.domain = Domain.ship modifier_post_mul.filter_type = FilterType.all_ modifier_post_mul.filter_value = None effect_post_mul = self.ch.effect(effect_id=6, category=EffectCategory.passive) effect_post_mul.modifiers = (modifier_post_mul, ) value_post_mul = 1.35 influence_source_post_mul = IndependentItem( self.ch.type_(type_id=6, effects=(effect_post_mul, ), attributes={src_attr.id: value_post_mul})) self.fit.items.add(influence_source_post_mul) modifier_post_div = Modifier() modifier_post_div.state = State.offline modifier_post_div.scope = Scope.local modifier_post_div.src_attr = src_attr.id modifier_post_div.operator = Operator.post_div modifier_post_div.tgt_attr = tgt_attr.id modifier_post_div.domain = Domain.ship modifier_post_div.filter_type = FilterType.all_ modifier_post_div.filter_value = None effect_post_div = self.ch.effect(effect_id=7, category=EffectCategory.passive) effect_post_div.modifiers = (modifier_post_div, ) value_post_div = 2.7 influence_source_post_div = IndependentItem( self.ch.type_(type_id=7, effects=(effect_post_div, ), attributes={src_attr.id: value_post_div})) self.fit.items.add(influence_source_post_div) modifier_post_perc = Modifier() modifier_post_perc.state = State.offline modifier_post_perc.scope = Scope.local modifier_post_perc.src_attr = src_attr.id modifier_post_perc.operator = Operator.post_percent modifier_post_perc.tgt_attr = tgt_attr.id modifier_post_perc.domain = Domain.ship modifier_post_perc.filter_type = FilterType.all_ modifier_post_perc.filter_value = None effect_post_perc = self.ch.effect(effect_id=8, category=EffectCategory.passive) effect_post_perc.modifiers = (modifier_post_perc, ) value_post_perc = 15 influence_source_post_perc = IndependentItem( self.ch.type_(type_id=8, effects=(effect_post_perc, ), attributes={src_attr.id: value_post_perc})) self.fit.items.add(influence_source_post_perc) influence_target = ShipItem( self.ch.type_(type_id=9, attributes={tgt_attr.id: 100})) self.fit.items.add(influence_target) # Operators shouldn't be penalized and should go in this order exp_value = (((value_pre_ass * value_pre_mul / value_pre_div) + value_mod_add - value_mod_sub) * value_post_mul / value_post_div * (1 + value_post_perc / 100)) self.assertAlmostEqual(influence_target.attributes[tgt_attr.id], exp_value) self.fit.items.remove(influence_source_pre_ass) self.fit.items.remove(influence_source_pre_mul) self.fit.items.remove(influence_source_pre_div) self.fit.items.remove(influence_source_mod_add) self.fit.items.remove(influence_source_mod_sub) self.fit.items.remove(influence_source_post_mul) self.fit.items.remove(influence_source_post_div) self.fit.items.remove(influence_source_post_perc) self.fit.items.remove(influence_target) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_calculation(self): attr1 = self.ch.attribute(attribute_id=1) attr2 = self.ch.attribute(attribute_id=2) attr3 = self.ch.attribute(attribute_id=3) attr4 = self.ch.attribute(attribute_id=4) modifier1 = Modifier() modifier1.state = State.offline modifier1.scope = Scope.local modifier1.src_attr = attr1.id modifier1.operator = Operator.post_mul modifier1.tgt_attr = attr2.id modifier1.domain = Domain.self_ modifier1.filter_type = None modifier1.filter_value = None effect1 = self.ch.effect(effect_id=1, category=EffectCategory.passive) effect1.modifiers = (modifier1, ) modifier2 = Modifier() modifier2.state = State.offline modifier2.scope = Scope.local modifier2.src_attr = attr2.id modifier2.operator = Operator.post_percent modifier2.tgt_attr = attr3.id modifier2.domain = Domain.ship modifier2.filter_type = None modifier2.filter_value = None effect2 = self.ch.effect(effect_id=2, category=EffectCategory.passive) effect2.modifiers = (modifier2, ) holder1 = CharacterItem( self.ch.type_(type_id=1, effects=(effect1, effect2), attributes={ attr1.id: 5, attr2.id: 20 })) modifier3 = Modifier() modifier3.state = State.offline modifier3.scope = Scope.local modifier3.src_attr = attr3.id modifier3.operator = Operator.post_percent modifier3.tgt_attr = attr4.id modifier3.domain = Domain.ship modifier3.filter_type = FilterType.all_ modifier3.filter_value = None effect3 = self.ch.effect(effect_id=3, category=EffectCategory.passive) effect3.modifiers = (modifier3, ) holder2 = IndependentItem( self.ch.type_(type_id=2, effects=(effect3, ), attributes={attr3.id: 150})) holder3 = ShipItem( self.ch.type_(type_id=3, attributes={attr4.id: 12.5})) self.fit.items.add(holder1) self.fit.ship = holder2 self.fit.items.add(holder3) # If everything is processed properly, holder1 will multiply attr2 by attr1 # on self, resulting in 20 * 5 = 100, then apply it as percentage modifier # on ship's (holder2) attr3, resulting in 150 + 100% = 300, then it is applied # to all entities assigned to ship, including holder3, to theirs attr4 as # percentage modifier again - so final result is 12.5 + 300% = 50 self.assertAlmostEqual(holder3.attributes[attr4.id], 50) self.fit.items.remove(holder1) self.fit.ship = None self.fit.items.remove(holder3) self.assertEqual(len(self.log), 0) self.assert_link_buffers_empty(self.fit)
def test_source_attr_update(self): # Here we check if attributes are updated if fit gets new # source instance; we do not actually switch source but we # switch cache_handler, and it should be enough cache_handler1 = CacheHandler() cache_handler2 = CacheHandler() src_attr1 = cache_handler1.attribute(attribute_id=1) tgt_attr1 = cache_handler1.attribute(attribute_id=2, max_attribute=33) cache_handler1.attribute(attribute_id=33, default_value=100) src_attr2 = cache_handler2.attribute(attribute_id=1) tgt_attr2 = cache_handler2.attribute(attribute_id=2, max_attribute=333) cache_handler2.attribute(attribute_id=333, default_value=500) modifier = Modifier() modifier.state = State.offline modifier.scope = Scope.local modifier.src_attr = 1 modifier.operator = Operator.post_percent modifier.tgt_attr = 2 modifier.domain = Domain.ship modifier.filter_type = FilterType.all_ modifier.filter_value = None effect1 = cache_handler1.effect(effect_id=1, category=EffectCategory.passive) effect1.modifiers = (modifier,) effect2 = cache_handler1.effect(effect_id=111, category=EffectCategory.passive) effect2.modifiers = (modifier,) # Our holders from test environment fo not update undelying # item automatically when source is changed, thus we do it # manually ship_item1 = cache_handler1.type_(type_id=8, effects=(effect1,), attributes={src_attr1.id: 10}) ship_item2 = cache_handler2.type_(type_id=8, effects=(effect2,), attributes={src_attr2.id: 20}) module_item1 = cache_handler1.type_(type_id=4, attributes={tgt_attr1.id: 50}) module_item2 = cache_handler2.type_(type_id=4, attributes={tgt_attr2.id: 75}) fit = Fit(cache_handler1) ship = IndependentItem(ship_item1) module = ShipItem(module_item1) fit.ship = ship fit.items.add(module) self.assertAlmostEqual(module.attributes.get(tgt_attr1.id), 55) # As we have capped attr, this auxiliary map shouldn't be None self.assertIsNotNone(module.attributes._cap_map) # Make an 'source switch': remove holders from attribute_calculator for holder in (ship, module): disabled_states = set(filter(lambda s: s <= holder.state, State)) fit._link_tracker.disable_states(holder, disabled_states) fit._link_tracker.remove_holder(holder) # Refresh holders and replace source fit.source.cache_handler = cache_handler2 ship.attributes.clear() ship.item = ship_item2 module.attributes.clear() module.item = module_item2 # When we cleared holders, auxiliary map for capped attrs should be None. # Using data in this map, attributes which depend on capping attribute will # be cleared. If we don't clear it, there're chances that in new data this # capping-capped attribute pair won't exist, thus if attribute with ID which # used to cap is changed, it will clear attribute which used to be capped - # and we do not want it within scope of new data. self.assertIsNone(module.attributes._cap_map) # Add holders again, when new items are in holders for holder in (ship, module): fit._link_tracker.add_holder(holder) enabled_states = set(filter(lambda s: s <= holder.state, State)) fit._link_tracker.enable_states(holder, enabled_states) # Now we should have calculated value based on both updated attribs # if attribs weren't refreshed, we would use old value for modification # (10 instead of 20) self.assertAlmostEqual(module.attributes.get(tgt_attr2.id), 90) fit.ship = None fit.items.remove(module) self.assert_link_buffers_empty(fit)