Beispiel #1
0
 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)
Beispiel #2
0
 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)
Beispiel #3
0
 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)
Beispiel #4
0
 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)