def __init__(self):
# Container for skill holders, for ease of
# access
# Format: {holder id: {holders}}
self.__skillHolders = KeyedSet()
# Set with holders which have any skill requirements
# Format: {holders}
self.__restrictedHolders = set()
def __init__(self, slotIndexAttr, restrictionType):
# This attribute's value on holder
# represents their index of slot
self.__slotIndexAttr = slotIndexAttr
self.__restrictionType = restrictionType
# All holders which possess index of slot
# are stored in this container
# Format: {slot index: {holders}}
self.__slottedHolders = KeyedSet()
def __init__(self, maxGroupAttr, restrictionType):
# Attribute ID whose value contains group restriction
# of holder
self.__maxGroupAttr = maxGroupAttr
self.__restrictionType = restrictionType
# Container for all tracked holders, keyed
# by their group ID
# Format: {group ID: {holders}}
self.__groupAll = KeyedSet()
# Container for holders, which have max group
# restriction to become operational
# Format: {holders}
self.__maxGroupRestricted = set()
class SlotIndexRegister(RestrictionRegister):
"""
Class which implements common functionality for all
registers, which track indices of occupied slots and
disallow multiple holders reside within slot with the
same index.
"""
def __init__(self, slotIndexAttr, restrictionType):
# This attribute's value on holder
# represents their index of slot
self.__slotIndexAttr = slotIndexAttr
self.__restrictionType = restrictionType
# All holders which possess index of slot
# are stored in this container
# Format: {slot index: {holders}}
self.__slottedHolders = KeyedSet()
def registerHolder(self, holder):
# Skip items which don't have index specifier
try:
slotIndex = holder.item.attributes[self.__slotIndexAttr]
except KeyError:
return
self.__slottedHolders.addData(slotIndex, holder)
def unregisterHolder(self, holder):
try:
slotIndex = holder.item.attributes[self.__slotIndexAttr]
except KeyError:
return
self.__slottedHolders.rmData(slotIndex, holder)
def validate(self):
taintedHolders = {}
for slotIndex in self.__slottedHolders:
slotIndexHolders = self.__slottedHolders[slotIndex]
# If more than one item occupies the same slot, all
# holders in this slot are tainted
if len(slotIndexHolders) > 1:
for holder in slotIndexHolders:
taintedHolders[holder] = SlotIndexErrorData(holderSlotIndex=slotIndex)
if taintedHolders:
raise RegisterValidationError(taintedHolders)
@property
def restrictionType(self):
return self.__restrictionType
class SlotIndexRegister(RestrictionRegister):
"""
Class which implements common functionality for all
registers, which track indices of occupied slots and
disallow multiple holders reside within slot with the
same index.
"""
def __init__(self, slotIndexAttr, restrictionType):
# This attribute's value on holder
# represents their index of slot
self.__slotIndexAttr = slotIndexAttr
self.__restrictionType = restrictionType
# All holders which possess index of slot
# are stored in this container
# Format: {slot index: {holders}}
self.__slottedHolders = KeyedSet()
def registerHolder(self, holder):
# Skip items which don't have index specifier
try:
slotIndex = holder.item.attributes[self.__slotIndexAttr]
except KeyError:
return
self.__slottedHolders.addData(slotIndex, holder)
def unregisterHolder(self, holder):
try:
slotIndex = holder.item.attributes[self.__slotIndexAttr]
except KeyError:
return
self.__slottedHolders.rmData(slotIndex, holder)
def validate(self):
taintedHolders = {}
for slotIndex in self.__slottedHolders:
slotIndexHolders = self.__slottedHolders[slotIndex]
# If more than one item occupies the same slot, all
# holders in this slot are tainted
if len(slotIndexHolders) > 1:
for holder in slotIndexHolders:
taintedHolders[holder] = SlotIndexErrorData(
holderSlotIndex=slotIndex)
if taintedHolders:
raise RegisterValidationError(taintedHolders)
@property
def restrictionType(self):
return self.__restrictionType
def __init__(self):
# Container for skill holders, for ease of
# access
# Format: {holder id: {holders}}
self.__skillHolders = KeyedSet()
# Set with holders which have any skill requirements
# Format: {holders}
self.__restrictedHolders = set()
def __init__(self, slotIndexAttr, restrictionType):
# This attribute's value on holder
# represents their index of slot
self.__slotIndexAttr = slotIndexAttr
self.__restrictionType = restrictionType
# All holders which possess index of slot
# are stored in this container
# Format: {slot index: {holders}}
self.__slottedHolders = KeyedSet()
class SkillUniquenessRegister(RestrictionRegister):
"""
Implements restriction:
Fit can't have more than one skill based on the same type.
Details:
Only holders having level attribute and item typeID other
than None are tracked.
"""
def __init__(self):
# Container for skill holders
# Format: {holder id: {holders}}
self.__skillHolders = KeyedSet()
def registerHolder(self, holder):
# Only holders which have level attribute are tracked as skills
if hasattr(holder, 'level') is True and holder.item.id is not None:
self.__skillHolders.addData(holder.item.id, holder)
def unregisterHolder(self, holder):
self.__skillHolders.rmData(holder.item.id, holder)
def validate(self):
taintedHolders = {}
# Go through all skill IDs
for skillId in self.__skillHolders:
skillHolders = self.__skillHolders[skillId]
# If there's at least two skills with the same ID,
# taint these holders
if len(skillHolders) > 1:
for holder in skillHolders:
taintedHolders[holder] = SkillUniquenessErrorData(skill=skillId)
if taintedHolders:
raise RegisterValidationError(taintedHolders)
@property
def restrictionType(self):
return Restriction.skillUniqueness
class SkillUniquenessRegister(RestrictionRegister):
"""
Implements restriction:
Fit can't have more than one skill based on the same type.
Details:
Only holders having level attribute and item typeID other
than None are tracked.
"""
def __init__(self):
# Container for skill holders
# Format: {holder id: {holders}}
self.__skillHolders = KeyedSet()
def registerHolder(self, holder):
# Only holders which have level attribute are tracked as skills
if hasattr(holder, "level") is True and holder.item.id is not None:
self.__skillHolders.addData(holder.item.id, holder)
def unregisterHolder(self, holder):
self.__skillHolders.rmData(holder.item.id, holder)
def validate(self):
taintedHolders = {}
# Go through all skill IDs
for skillId in self.__skillHolders:
skillHolders = self.__skillHolders[skillId]
# If there's at least two skills with the same ID,
# taint these holders
if len(skillHolders) > 1:
for holder in skillHolders:
taintedHolders[holder] = SkillUniquenessErrorData(skill=skillId)
if taintedHolders:
raise RegisterValidationError(taintedHolders)
@property
def restrictionType(self):
return Restriction.skillUniqueness
def __init__(self, maxGroupAttr, restrictionType):
# Attribute ID whose value contains group restriction
# of holder
self.__maxGroupAttr = maxGroupAttr
self.__restrictionType = restrictionType
# Container for all tracked holders, keyed
# by their group ID
# Format: {group ID: {holders}}
self.__groupAll = KeyedSet()
# Container for holders, which have max group
# restriction to become operational
# Format: {holders}
self.__maxGroupRestricted = set()
def __init__(self, fit):
# Link tracker which is assigned to fit we're
# keeping data for
self._fit = fit
# Keep track of holders belonging to certain location
# Format: {location: {targetHolders}}
self.__affecteeLocation = KeyedSet()
# Keep track of holders belonging to certain location and group
# Format: {(location, group): {targetHolders}}
self.__affecteeLocationGroup = KeyedSet()
# Keep track of holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {targetHolders}}
self.__affecteeLocationSkill = KeyedSet()
# Keep track of affectors influencing all holders belonging to certain location
# Format: {location: {affectors}}
self.__affectorLocation = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and group
# Format: {(location, group): {affectors}}
self.__affectorLocationGroup = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {affectors}}
self.__affectorLocationSkill = KeyedSet()
# Keep track of affectors influencing holders directly
# Format: {targetHolder: {affectors}}
self.__activeDirectAffectors = KeyedSet()
# Keep track of affectors which influence something directly,
# but are disabled as their target location is not available
# Format: {sourceHolder: {affectors}}
self.__disabledDirectAffectors = KeyedSet()
def __init__(self, tracker):
# The fit we're keeping track of things for
self.__tracker = tracker
# Keep track of holders belonging to certain location
# Format: {location: {targetHolders}}
self.__affecteeLocation = KeyedSet()
# Keep track of holders belonging to certain location and group
# Format: {(location, group): {targetHolders}}
self.__affecteeLocationGroup = KeyedSet()
# Keep track of holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {targetHolders}}
self.__affecteeLocationSkill = KeyedSet()
# Keep track of affectors influencing all holders belonging to certain location
# Format: {location: {affectors}}
self.__affectorLocation = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and group
# Format: {(location, group): {affectors}}
self.__affectorLocationGroup = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {affectors}}
self.__affectorLocationSkill = KeyedSet()
# Keep track of affectors influencing holders directly
# Format: {targetHolder: {affectors}}
self.__activeDirectAffectors = KeyedSet()
# Keep track of affectors which influence locOther, but are disabled
# as their target location is not available
# Format: {sourceHolder: {affectors}}
self.__disabledDirectAffectors = KeyedSet()
def __init__(self, fit):
# Link tracker which is assigned to fit we're
# keeping data for
self._fit = fit
# Keep track of holders belonging to certain location
# Format: {location: {targetHolders}}
self.__affecteeLocation = KeyedSet()
# Keep track of holders belonging to certain location and group
# Format: {(location, group): {targetHolders}}
self.__affecteeLocationGroup = KeyedSet()
# Keep track of holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {targetHolders}}
self.__affecteeLocationSkill = KeyedSet()
# Keep track of affectors influencing all holders belonging to certain location
# Format: {location: {affectors}}
self.__affectorLocation = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and group
# Format: {(location, group): {affectors}}
self.__affectorLocationGroup = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {affectors}}
self.__affectorLocationSkill = KeyedSet()
# Keep track of affectors influencing holders directly
# Format: {targetHolder: {affectors}}
self.__activeDirectAffectors = KeyedSet()
# Keep track of affectors which influence something directly,
# but are disabled as their target location is not available
# Format: {sourceHolder: {affectors}}
self.__disabledDirectAffectors = KeyedSet()
def __init__(self):
# Container for skill holders
# Format: {holder id: {holders}}
self.__skillHolders = KeyedSet()
class MaxGroupRegister(RestrictionRegister):
"""
Class which implements common functionality for all
registers, which track maximum number of belonging to
ship holders in certain state on per-group basis.
"""
def __init__(self, maxGroupAttr, restrictionType):
# Attribute ID whose value contains group restriction
# of holder
self.__maxGroupAttr = maxGroupAttr
self.__restrictionType = restrictionType
# Container for all tracked holders, keyed
# by their group ID
# Format: {group ID: {holders}}
self.__groupAll = KeyedSet()
# Container for holders, which have max group
# restriction to become operational
# Format: {holders}
self.__maxGroupRestricted = set()
def registerHolder(self, holder):
# Ignore holders which do not belong to ship
if holder._location != Location.ship:
return
groupId = holder.item.groupId
# Ignore holders, whose item isn't assigned
# to any group
if groupId is None:
return
# Having group ID is enough condition
# to enter container of all fitted holders
self.__groupAll.addData(groupId, holder)
# To enter restriction container, original
# item must have restriction attribute
if self.__maxGroupAttr not in holder.item.attributes:
return
self.__maxGroupRestricted.add(holder)
def unregisterHolder(self, holder):
# Just clear data containers
groupId = holder.item.groupId
self.__groupAll.rmData(groupId, holder)
self.__maxGroupRestricted.discard(holder)
def validate(self):
# Container for tainted holders
taintedHolders = {}
# Go through all restricted holders
for holder in self.__maxGroupRestricted:
# Get number of registered holders, assigned to group of current
# restricted holder, and holder's restriction value
groupId = holder.item.groupId
groupHolders = len(self.__groupAll.get(groupId) or ())
maxGroupRestriction = holder.item.attributes[self.__maxGroupAttr]
# If number of registered holders from this group is bigger,
# then current holder is tainted
if groupHolders > maxGroupRestriction:
taintedHolders[holder] = MaxGroupErrorData(maxGroup=maxGroupRestriction,
holderGroup=groupId,
groupHolders=groupHolders)
# Raise error if we detected any tainted holders
if taintedHolders:
raise RegisterValidationError(taintedHolders)
@property
def restrictionType(self):
return self.__restrictionType
def __calculate(self, attrId):
"""
Run calculations to find the actual value of attribute.
Positional arguments:
attrId -- ID of attribute to be calculated
Return value:
Calculated attribute value
Possible exceptions:
BaseValueError -- attribute cannot be calculated, as its
base value is not available
"""
# Attribute object for attribute being calculated
try:
attrMeta = self.__holder._fit.eos._cacheHandler.getAttribute(
attrId)
# Raise error if we can't get to getAttribute method
# or it can't find requested attribute
except (AttributeError, AttributeFetchError) as e:
raise AttributeMetaError(attrId) from e
# Base attribute value which we'll use for modification
try:
result = self.__holder.item.attributes[attrId]
# If attribute isn't available on base item,
# base off its default value
except KeyError:
result = attrMeta.defaultValue
# If original attribute is not specified and default
# value isn't available, raise error - without valid
# base we can't go on
if result is None:
raise BaseValueError(attrId)
# Container for non-penalized modifiers
# Format: {operator: [values]}
normalMods = {}
# Container for penalized modifiers
# Format: {operator: [values]}
penalizedMods = {}
# Now, go through all affectors affecting our holder
for affector in self.__holder._fit._linkTracker.getAffectors(
self.__holder, attrId=attrId):
try:
sourceHolder, modifier = affector
operator = modifier.operator
# Decide if it should be stacking penalized or not, based on stackable property,
# source item category and operator
penalize = (attrMeta.stackable is False
and sourceHolder.item.categoryId
not in penaltyImmuneCategories
and operator in penalizableOperators)
try:
modValue = sourceHolder.attributes[
modifier.sourceAttributeId]
# Silently skip current affector: error should already
# be logged by map before it raised KeyError
except KeyError:
continue
# Normalize operations to just three types:
# assignments, additions, multiplications
try:
normalizationFunc = normalizationMap[operator]
# Raise error on any unknown operator types
except KeyError as e:
raise OperatorError(operator) from e
modValue = normalizationFunc(modValue)
# Add value to appropriate dictionary
if penalize is True:
modList = penalizedMods.setdefault(operator, [])
else:
modList = normalMods.setdefault(operator, [])
modList.append(modValue)
# Handle operator type failure
except OperatorError as e:
msg = 'malformed modifier on item {}: unknown operator {}'.format(
sourceHolder.item.id, e.args[0])
signature = (type(e), sourceHolder.item.id, e.args[0])
self.__holder._fit.eos._logger.warning(
msg, childName='attributeCalculator', signature=signature)
continue
# When data gathering is complete, process penalized modifiers
# They are penalized on per-operator basis
for operator, modList in penalizedMods.items():
penalizedValue = self.__penalizeValues(modList)
modList = normalMods.setdefault(operator, [])
modList.append(penalizedValue)
# Calculate result of normal dictionary, according to operator order
for operator in sorted(normalMods):
modList = normalMods[operator]
# Pick best modifier for assignments, based on highIsGood value
if operator in assignments:
result = max(modList) if attrMeta.highIsGood is True else min(
modList)
elif operator in additions:
for modVal in modList:
result += modVal
elif operator in multiplications:
for modVal in modList:
result *= modVal
# If attribute has upper cap, do not let
# its value to grow above it
if attrMeta.maxAttributeId is not None:
try:
maxValue = self[attrMeta.maxAttributeId]
# If max value isn't available, don't
# cap anything
except KeyError:
pass
else:
result = min(result, maxValue)
# Let map know that capping attribute
# restricts current attribute
if self._capMap is None:
self._capMap = KeyedSet()
# Fill cap map with data: capping attribute and capped attribute
self._capMap.addData(attrMeta.maxAttributeId, attrId)
return result
class LinkRegister:
"""
Keep track of currently existing links between affectors
(Affector objects) and affectees (holders). This is hard
requirement for efficient partial attribute recalculation.
Register is not aware of links between specific attributes,
doesn't know anything about states and contexts, just
affectors and affectees.
Positional arguments:
fit -- fit, to which this register is bound to
"""
def __init__(self, fit):
# Link tracker which is assigned to fit we're
# keeping data for
self._fit = fit
# Keep track of holders belonging to certain location
# Format: {location: {targetHolders}}
self.__affecteeLocation = KeyedSet()
# Keep track of holders belonging to certain location and group
# Format: {(location, group): {targetHolders}}
self.__affecteeLocationGroup = KeyedSet()
# Keep track of holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {targetHolders}}
self.__affecteeLocationSkill = KeyedSet()
# Keep track of affectors influencing all holders belonging to certain location
# Format: {location: {affectors}}
self.__affectorLocation = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and group
# Format: {(location, group): {affectors}}
self.__affectorLocationGroup = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {affectors}}
self.__affectorLocationSkill = KeyedSet()
# Keep track of affectors influencing holders directly
# Format: {targetHolder: {affectors}}
self.__activeDirectAffectors = KeyedSet()
# Keep track of affectors which influence something directly,
# but are disabled as their target location is not available
# Format: {sourceHolder: {affectors}}
self.__disabledDirectAffectors = KeyedSet()
def registerAffectee(self, targetHolder):
"""
Add passed target holder to register's maps, so it can be affected by
other holders properly.
Positional arguments:
targetHolder -- holder to register
"""
for key, affecteeMap in self.__getAffecteeMaps(targetHolder):
# Add data to map
affecteeMap.addData(key, targetHolder)
# Check if we have affectors which should directly influence passed holder,
# but are disabled; enable them if there're any
enableDirect = self.__getHolderDirectLocation(targetHolder)
if enableDirect is None:
return
if enableDirect == Location.other:
self.__enableDirectOther(targetHolder)
elif enableDirect in (Location.character, Location.ship):
self.__enableDirectSpec(targetHolder, enableDirect)
def unregisterAffectee(self, targetHolder):
"""
Remove passed target holder from register's maps, so holders affecting
it "know" that its modification is no longer needed.
Positional arguments:
targetHolder -- holder to unregister
"""
for key, affecteeMap in self.__getAffecteeMaps(targetHolder):
affecteeMap.rmData(key, targetHolder)
# When removing holder from register, make sure to move modifiers which
# originate from 'other' holders and directly affect it to disabled map
disableDirect = self.__getHolderDirectLocation(targetHolder)
if disableDirect is None:
return
if disableDirect is None:
return
if disableDirect == Location.other:
self.__disableDirectOther(targetHolder)
elif disableDirect in (Location.character, Location.ship):
self.__disableDirectSpec(targetHolder)
def registerAffector(self, affector):
"""
Add passed affector to register's affector maps, so that new holders
added to fit know that they should be affected by it.
Positional arguments:
affector -- affector to register
"""
try:
key, affectorMap = self.__getAffectorMap(affector)
# Actually add data to map
affectorMap.addData(key, affector)
except Exception as e:
self.__handleAffectorErrors(e, affector)
def unregisterAffector(self, affector):
"""
Remove passed affector from register's affector maps, so that
holders-affectees "know" that they're no longer affected by it.
Positional arguments:
affector -- affector to unregister
"""
try:
key, affectorMap = self.__getAffectorMap(affector)
affectorMap.rmData(key, affector)
# Following block handles exceptions; all of them must be handled
# when registering affector too, thus they won't appear in log
# if logger's handler suppresses messages with duplicate
# signature
except Exception as e:
self.__handleAffectorErrors(e, affector)
def getAffectees(self, affector):
"""
Get all holders influenced by passed affector.
Positional arguments:
affector -- affector, for which we're seeking for affectees
Return value:
Set with holders, being influenced by affector
"""
sourceHolder, modifier = affector
affectees = set()
try:
# For direct modification, make set out of single target location
if modifier.filterType is None:
if modifier.location == Location.self_:
target = {sourceHolder}
elif modifier.location == Location.character:
char = self._fit.character
target = {char} if char is not None else None
elif modifier.location == Location.ship:
ship = self._fit.ship
target = {ship} if ship is not None else None
elif modifier.location == Location.other:
try:
otherHolder = sourceHolder._other
except AttributeError:
otherHolder = None
target = {otherHolder} if otherHolder is not None else None
else:
raise DirectLocationError(modifier.location)
# For filtered modifications, pick appropriate dictionary and get set
# with target holders
elif modifier.filterType == FilterType.all_:
key = self.__contextizeFilterLocation(affector)
target = self.__affecteeLocation.get(key) or set()
elif modifier.filterType == FilterType.group:
location = self.__contextizeFilterLocation(affector)
key = (location, modifier.filterValue)
target = self.__affecteeLocationGroup.get(key) or set()
elif modifier.filterType == FilterType.skill:
location = self.__contextizeFilterLocation(affector)
skill = affector.modifier.filterValue
key = (location, skill)
target = self.__affecteeLocationSkill.get(key) or set()
elif modifier.filterType == FilterType.skillSelf:
location = self.__contextizeFilterLocation(affector)
skill = affector.sourceHolder.item.id
key = (location, skill)
target = self.__affecteeLocationSkill.get(key) or set()
else:
raise FilterTypeError(modifier.filterType)
# Add our set to affectees
if target is not None:
affectees.update(target)
# If passed affector has already been registered and logger prefers
# to suppress messages with duplicate signatures, following error handling
# won't produce new log entries
except Exception as e:
self.__handleAffectorErrors(e, affector)
return affectees
def getAffectors(self, targetHolder):
"""
Get all affectors, which influence passed holder.
Positional arguments:
targetHolder -- holder, for which we're seeking for affecting it
affectors
Return value:
Set with affectors, incluencing targetHolder
"""
affectors = set()
# Add all affectors which directly affect it
affectors.update(self.__activeDirectAffectors.get(targetHolder) or set())
# Then all affectors which affect location of passed holder
location = targetHolder._location
affectors.update(self.__affectorLocation.get(location) or set())
# All affectors which affect location and group of passed holder
group = targetHolder.item.groupId
affectors.update(self.__affectorLocationGroup.get((location, group)) or set())
# Same, but for location & skill requirement of passed holder
for skill in targetHolder.item.requiredSkills:
affectors.update(self.__affectorLocationSkill.get((location, skill)) or set())
return affectors
# General-purpose auxiliary methods
def __getAffecteeMaps(self, targetHolder):
"""
Helper for affectee register/unregister methods.
Positional arguments:
targetHolder -- holder, for which affectee maps are requested
Return value:
List of (key, affecteeMap) tuples, where key should be used to access
data set (appropriate to passed targetHolder) in affecteeMap
"""
# Container which temporarily holds (key, map) tuples
affecteeMaps = []
location = targetHolder._location
if location is not None:
affecteeMaps.append((location, self.__affecteeLocation))
group = targetHolder.item.groupId
if group is not None:
affecteeMaps.append(((location, group), self.__affecteeLocationGroup))
for skill in targetHolder.item.requiredSkills:
affecteeMaps.append(((location, skill), self.__affecteeLocationSkill))
return affecteeMaps
def __getAffectorMap(self, affector):
"""
Helper for affector register/unregister methods.
Positional arguments:
affector -- affector, for which affector map are requested
Return value:
(key, affectorMap) tuple, where key should be used to access
data set (appropriate to passed affector) in affectorMap
Possible exceptions:
FilteredSelfReferenceError -- raised if affector's modifier specifies
filtered modification and target location refers self, but affector's
holder isn't in position to be target for filtered modifications
DirectLocationError -- raised when affector's modifier target
location is not supported for direct modification
FilteredLocationError -- raised when affector's modifier target
location is not supported for filtered modification
FilterTypeError -- raised when affector's modifier filter type is not
supported
"""
sourceHolder, modifier = affector
# For each filter type, define affector map and key to use
if modifier.filterType is None:
# For direct modifications, we need to properly pick
# target holder (it's key) based on location
if modifier.location == Location.self_:
affectorMap = self.__activeDirectAffectors
key = sourceHolder
elif modifier.location == Location.character:
char = self._fit.character
if char is not None:
affectorMap = self.__activeDirectAffectors
key = char
else:
affectorMap = self.__disabledDirectAffectors
key = sourceHolder
elif modifier.location == Location.ship:
ship = self._fit.ship
if ship is not None:
affectorMap = self.__activeDirectAffectors
key = ship
else:
affectorMap = self.__disabledDirectAffectors
key = sourceHolder
# When other location is referenced, it means direct reference to module's charge
# or to charge's module-container
elif modifier.location == Location.other:
try:
otherHolder = sourceHolder._other
except AttributeError:
otherHolder = None
if otherHolder is not None:
affectorMap = self.__activeDirectAffectors
key = otherHolder
# When no reference available, it means that e.g. charge may be
# unavailable for now; use disabled affectors map for these
else:
affectorMap = self.__disabledDirectAffectors
key = sourceHolder
else:
raise DirectLocationError(modifier.location)
# For filtered modifications, compose key, making sure reference to self
# is converted into appropriate real location
elif modifier.filterType == FilterType.all_:
affectorMap = self.__affectorLocation
location = self.__contextizeFilterLocation(affector)
key = location
elif modifier.filterType == FilterType.group:
affectorMap = self.__affectorLocationGroup
location = self.__contextizeFilterLocation(affector)
key = (location, modifier.filterValue)
elif modifier.filterType == FilterType.skill:
affectorMap = self.__affectorLocationSkill
location = self.__contextizeFilterLocation(affector)
skill = affector.modifier.filterValue
key = (location, skill)
elif modifier.filterType == FilterType.skillSelf:
affectorMap = self.__affectorLocationSkill
location = self.__contextizeFilterLocation(affector)
skill = affector.sourceHolder.item.id
key = (location, skill)
else:
raise FilterTypeError(modifier.filterType)
return key, affectorMap
def __handleAffectorErrors(self, error, affector):
"""
Multiple register methods which get data based on passed affector
raise similar exception classes. To handle them in consistent fashion,
it is done from centralized place - this method. If error cannot be
handled by method, it is re-raised.
Positional arguments:
error -- Exception instance which was caught and needs to be handled
affector -- affector object, which was being processed when error occurred
"""
if isinstance(error, DirectLocationError):
msg = 'malformed modifier on item {}: unsupported target location {} for direct modification'.format(affector.sourceHolder.item.id, error.args[0])
signature = (type(error), affector.sourceHolder.item.id, error.args[0])
self._fit.eos._logger.warning(msg, childName='attributeCalculator', signature=signature)
elif isinstance(error, FilteredLocationError):
msg = 'malformed modifier on item {}: unsupported target location {} for filtered modification'.format(affector.sourceHolder.item.id, error.args[0])
signature = (type(error), affector.sourceHolder.item.id, error.args[0])
self._fit.eos._logger.warning(msg, childName='attributeCalculator', signature=signature)
elif isinstance(error, FilteredSelfReferenceError):
msg = 'malformed modifier on item {}: invalid reference to self for filtered modification'.format(affector.sourceHolder.item.id)
signature = (type(error), affector.sourceHolder.item.id)
self._fit.eos._logger.warning(msg, childName='attributeCalculator', signature=signature)
elif isinstance(error, FilterTypeError):
msg = 'malformed modifier on item {}: invalid filter type {}'.format(affector.sourceHolder.item.id, error.args[0])
signature = (type(error), affector.sourceHolder.item.id, error.args[0])
self._fit.eos._logger.warning(msg, childName='attributeCalculator', signature=signature)
else:
raise error
# Methods which help to process filtered modifications
def __contextizeFilterLocation(self, affector):
"""
Convert location self-reference to real location, like
character or ship. Used only in modifications of multiple
filtered holders, direct modifications are processed out
of the context of this method.
Positional arguments:
affector -- affector, whose modifier refers location in question
Return value:
Real contextized location
Possible exceptions:
FilteredSelfReferenceError -- raised if affector's modifier
refers self, but affector's holder isn't in position to be
target for filtered modifications
FilteredLocationError -- raised when affector's modifier
target location is not supported for filtered modification
"""
sourceHolder = affector.sourceHolder
targetLocation = affector.modifier.location
# Reference to self is sparingly used in ship effects, so we must convert
# it to real location
if targetLocation == Location.self_:
if sourceHolder is self._fit.ship:
return Location.ship
elif sourceHolder is self._fit.character:
return Location.character
else:
raise FilteredSelfReferenceError
# Just return untouched location for all other valid cases
elif targetLocation in (Location.character, Location.ship, Location.space):
return targetLocation
# Raise error if location is invalid
else:
raise FilteredLocationError(targetLocation)
# Methods which help to process direct modifications
def __getHolderDirectLocation(self, holder):
"""
Get location which you need to target to apply
direct modification to passed holder.
Positional arguments:
holder -- holder in question
Return value:
Location specification, if holder can be targeted directly
from the outside, or None if it can't
"""
# For ship and character it's easy, we're just picking
# corresponding location
if holder is self._fit.ship:
location = Location.ship
elif holder is self._fit.character:
location = Location.character
# For "other" location, we should've checked for presence
# of other entity - charge's container or module's charge
elif getattr(holder, '_other', None) is not None:
location = Location.other
else:
location = None
return location
def __enableDirectSpec(self, targetHolder, targetLocation):
"""
Enable temporarily disabled affectors, directly targeting holder in
specific location.
Positional arguments:
targetHolder -- holder which is being registered
targetLocation -- location, to which holder is being registered
"""
# Format: {sourceHolder: [affectors]}
affectorsToEnable = {}
# Cycle through all disabled direct affectors
for sourceHolder, affectorSet in self.__disabledDirectAffectors.items():
for affector in affectorSet:
modifier = affector.modifier
# Mark affector as to-be-enabled only when it
# targets passed target location
if modifier.location == targetLocation:
sourceAffectors = affectorsToEnable.setdefault(sourceHolder, [])
sourceAffectors.append(affector)
# Bail if we have nothing to do
if not affectorsToEnable:
return
# Move all of them to direct modification dictionary
for sourceHolder, affectors in affectorsToEnable.items():
self.__disabledDirectAffectors.rmDataSet(sourceHolder, affectors)
self.__activeDirectAffectors.addDataSet(targetHolder, affectors)
def __disableDirectSpec(self, targetHolder):
"""
Disable affectors, directly targeting holder in specific location.
Positional arguments:
targetHolder -- holder which is being unregistered
"""
# Format: {sourceHolder: [affectors]}
affectorsToDisable = {}
# Check all affectors, targeting passed holder
for affector in self.__activeDirectAffectors.get(targetHolder) or ():
# Mark them as to-be-disabled only if they originate from
# other holder, else they should be removed with passed holder
if affector.sourceHolder is not targetHolder:
sourceAffectors = affectorsToDisable.setdefault(affector.sourceHolder, [])
sourceAffectors.append(affector)
if not affectorsToDisable:
return
# Move data from map to map
for sourceHolder, affectors in affectorsToDisable.items():
self.__activeDirectAffectors.rmDataSet(targetHolder, affectors)
self.__disabledDirectAffectors.addDataSet(sourceHolder, affectors)
def __enableDirectOther(self, targetHolder):
"""
Enable temporarily disabled affectors, directly targeting passed holder,
originating from holder in "other" location.
Positional arguments:
targetHolder -- holder which is being registered
"""
try:
otherHolder = targetHolder._other
except AttributeError:
otherHolder = None
# If passed holder doesn't have other location (charge's module
# or module's charge), do nothing
if otherHolder is None:
return
# Get all disabled affectors which should influence our targetHolder
affectorsToEnable = set()
for affector in self.__disabledDirectAffectors.get(otherHolder) or ():
modifier = affector.modifier
if modifier.location == Location.other:
affectorsToEnable.add(affector)
# Bail if we have nothing to do
if not affectorsToEnable:
return
# Move all of them to direct modification dictionary
self.__activeDirectAffectors.addDataSet(targetHolder, affectorsToEnable)
self.__disabledDirectAffectors.rmDataSet(otherHolder, affectorsToEnable)
def __disableDirectOther(self, targetHolder):
"""
Disable affectors, directly targeting passed holder, originating from
holder in "other" location.
Positional arguments:
targetHolder -- holder which is being unregistered
"""
try:
otherHolder = targetHolder._other
except AttributeError:
otherHolder = None
if otherHolder is None:
return
affectorsToDisable = set()
# Go through all affectors influencing holder being unregistered
for affector in self.__activeDirectAffectors.get(targetHolder) or ():
# If affector originates from otherHolder, mark it as
# to-be-disabled
if affector.sourceHolder is otherHolder:
affectorsToDisable.add(affector)
# Do nothing if we have no such affectors
if not affectorsToDisable:
return
# If we have, move them from map to map
self.__disabledDirectAffectors.addDataSet(otherHolder, affectorsToDisable)
self.__activeDirectAffectors.rmDataSet(targetHolder, affectorsToDisable)
class MutableAttributeMap:
"""
Calculate, store and provide access to modified attribute values.
Positional arguments:
holder -- holder, to which this map is assigned
"""
__slots__ = ("__holder", "__modifiedAttributes", "_capMap")
def __init__(self, holder):
# Reference to holder for internal needs
self.__holder = holder
# Actual container of calculated attributes
# Format: {attribute ID: value}
self.__modifiedAttributes = {}
# This variable stores map of attributes which cap
# something, and attributes capped by them. Initialized
# to None to not waste memory, will be changed to dict
# when needed.
# Format {capping attribute ID: {capped attribute IDs}}
self._capMap = None
def __getitem__(self, attrId):
# Special handling for skill level attribute
if attrId == Attribute.skillLevel:
# Attempt to return level attribute of holder
try:
val = self.__holder.level
# Try regular way of getting attribute, if accessing
# level attribute failed
except AttributeError:
pass
else:
return val
# If carrier holder isn't assigned to any fit, then
# we can use just item's original attributes
if self.__holder.fit is None:
val = self.__holder.item.attributes[attrId]
return val
# If value is stored, it's considered valid
try:
val = self.__modifiedAttributes[attrId]
# Else, we have to run full calculation process
except KeyError:
try:
val = self.__modifiedAttributes[attrId] = self.__calculate(attrId)
except BaseValueError as e:
msg = "unable to find base value for attribute {} on item {}".format(e.args[0], self.__holder.item.id)
signature = (type(e), self.__holder.item.id, e.args[0])
self.__holder.fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
raise KeyError(attrId) from e
except AttributeMetaError as e:
msg = "unable to fetch metadata for attribute {}, requested for item {}".format(e.args[0], self.__holder.item.id)
signature = (type(e), self.__holder.item.id, e.args[0])
self.__holder.fit._eos._logger.error(msg, childName="attributeCalculator", signature=signature)
raise KeyError(attrId) from e
self.__holder.fit._linkTracker.clearHolderAttributeDependents(self.__holder, attrId)
return val
def __len__(self):
return len(self.keys())
def __contains__(self, attrId):
# Seek for attribute in both modified attribute container
# and original item attributes
result = attrId in self.__modifiedAttributes or attrId in self.__holder.item.attributes
return result
def __iter__(self):
for k in self.keys():
yield k
def __delitem__(self, attrId):
# Clear the value in our calculated attributes dictionary
try:
del self.__modifiedAttributes[attrId]
# Do nothing if it wasn't calculated
except KeyError:
pass
# And make sure all other attributes relying on it
# are cleared too
else:
self.__holder.fit._linkTracker.clearHolderAttributeDependents(self.__holder, attrId)
def __setitem__(self, attrId, value):
# Write value and clear all attributes relying on it
self.__modifiedAttributes[attrId] = value
self.__holder.fit._linkTracker.clearHolderAttributeDependents(self.__holder, attrId)
def get(self, attrId, default=None):
try:
return self[attrId]
except KeyError:
return default
def keys(self):
# Return union of both keys which are already calculated in
return self.__modifiedAttributes.keys() | self.__holder.item.attributes.keys()
def clear(self):
self.__modifiedAttributes.clear()
def __calculate(self, attrId):
"""
Run calculations to find the actual value of attribute.
Positional arguments:
attrId -- ID of attribute to be calculated
Return value:
Calculated attribute value
Possible exceptions:
BaseValueError -- attribute cannot be calculated, as its
base value is not available
"""
# Attribute object for attribute being calculated
try:
attrMeta = self.__holder.item._cacheHandler.getAttribute(attrId)
# Raise error if we can't get to getAttribute method
# or it can't find requested attribute
except (AttributeError, AttributeFetchError) as e:
raise AttributeMetaError(attrId) from e
# Base attribute value which we'll use for modification
try:
result = self.__holder.item.attributes[attrId]
# If attribute isn't available on base item,
# base off its default value
except KeyError:
result = attrMeta.defaultValue
# If original attribute is not specified and default
# value isn't available, raise error - without valid
# base we can't go on
if result is None:
raise BaseValueError(attrId)
# Container for non-penalized modifiers
# Format: {operator: [values]}
normalMods = {}
# Container for penalized modifiers
# Format: {operator: [values]}
penalizedMods = {}
# Now, go through all affectors affecting our holder
for affector in self.__holder.fit._linkTracker.getAffectors(self.__holder, attrId=attrId):
try:
sourceHolder, modifier = affector
operator = modifier.operator
# Decide if it should be stacking penalized or not, based on stackable property,
# source item category and operator
penalize = (attrMeta.stackable is False and not sourceHolder.item.categoryId in penaltyImmuneCategories
and operator in penalizableOperators)
try:
modValue = sourceHolder.attributes[modifier.sourceAttributeId]
# Silently skip current affector: error should already
# be logged by map before it raised KeyError
except KeyError:
continue
# Normalize operations to just three types:
# assignments, additions, multiplications
try:
normalizationFunc = normalizationMap[operator]
# Raise error on any unknown operator types
except KeyError as e:
raise OperatorError(operator) from e
modValue = normalizationFunc(modValue)
# Add value to appropriate dictionary
if penalize is True:
try:
modList = penalizedMods[operator]
except KeyError:
modList = penalizedMods[operator] = []
else:
try:
modList = normalMods[operator]
except KeyError:
modList = normalMods[operator] = []
modList.append(modValue)
# Handle operator type failure
except OperatorError as e:
msg = "malformed modifier on item {}: unknown operator {}".format(sourceHolder.item.id, e.args[0])
signature = (type(e), sourceHolder.item.id, e.args[0])
self.__holder.fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
continue
# When data gathering is complete, process penalized modifiers
# They are penalized on per-operator basis
for operator, modList in penalizedMods.items():
penalizedValue = self.__penalizeValues(modList)
try:
modList = normalMods[operator]
except KeyError:
modList = normalMods[operator] = []
modList.append(penalizedValue)
# Calculate result of normal dictionary, according to operator order
for operator in sorted(normalMods):
modList = normalMods[operator]
# Pick best modifier for assignments, based on highIsGood value
if operator in assignments:
result = max(modList) if attrMeta.highIsGood is True else min(modList)
elif operator in additions:
for modVal in modList:
result += modVal
elif operator in multiplications:
for modVal in modList:
result *= modVal
# If attribute has upper cap, do not let
# its value to grow above it
if attrMeta.maxAttributeId is not None:
try:
maxValue = self[attrMeta.maxAttributeId]
# If max value isn't available, don't
# cap anything
except KeyError:
pass
else:
result = min(result, maxValue)
# Let map know that capping attribute
# restricts current attribute
if self._capMap is None:
self._capMap = KeyedSet()
# Fill cap map with data: capping attribute and capped attribute
self._capMap.addData(attrMeta.maxAttributeId, attrId)
return result
def __penalizeValues(self, modList):
"""
Calculate aggregated factor of passed factors, taking into
consideration stacking penalty.
Positional argument:
modList -- list of factors
Return value:
Final aggregated factor of passed modList
"""
# Gather positive modifiers into one chain, negative
# into another
chainPositive = []
chainNegative = []
for modVal in modList:
# Transform value into form of multiplier - 1 for ease of
# stacking chain calculation
modVal -= 1
if modVal >= 0:
chainPositive.append(modVal)
else:
chainNegative.append(modVal)
# Strongest modifiers always go first
chainPositive.sort(reverse=True)
chainNegative.sort()
# Base final multiplier on 1
listResult = 1
for chain in (chainPositive, chainNegative):
# Same for intermediate per-chain result
chainResult = 1
for position, modifier in enumerate(chain):
# Ignore 12th modifier and further as non-significant
if position > 10:
break
# Apply stacking penalty based on modifier position
chainResult *= 1 + modifier * penaltyBase ** (position ** 2)
listResult *= chainResult
return listResult
class MaxGroupRegister(RestrictionRegister):
"""
Class which implements common functionality for all
registers, which track maximum number of belonging to
ship holders in certain state on per-group basis.
"""
def __init__(self, maxGroupAttr, restrictionType):
# Attribute ID whose value contains group restriction
# of holder
self.__maxGroupAttr = maxGroupAttr
self.__restrictionType = restrictionType
# Container for all tracked holders, keyed
# by their group ID
# Format: {group ID: {holders}}
self.__groupAll = KeyedSet()
# Container for holders, which have max group
# restriction to become operational
# Format: {holders}
self.__maxGroupRestricted = set()
def registerHolder(self, holder):
# Ignore holders which do not belong to ship
if holder._location != Location.ship:
return
groupId = holder.item.groupId
# Ignore holders, whose item isn't assigned
# to any group
if groupId is None:
return
# Having group ID is enough condition
# to enter container of all fitted holders
self.__groupAll.addData(groupId, holder)
# To enter restriction container, original
# item must have restriction attribute
if self.__maxGroupAttr not in holder.item.attributes:
return
self.__maxGroupRestricted.add(holder)
def unregisterHolder(self, holder):
# Just clear data containers
groupId = holder.item.groupId
self.__groupAll.rmData(groupId, holder)
self.__maxGroupRestricted.discard(holder)
def validate(self):
# Container for tainted holders
taintedHolders = {}
# Go through all restricted holders
for holder in self.__maxGroupRestricted:
# Get number of registered holders, assigned to group of current
# restricted holder, and holder's restriction value
groupId = holder.item.groupId
groupHolders = len(self.__groupAll.get(groupId) or ())
maxGroupRestriction = holder.item.attributes[self.__maxGroupAttr]
# If number of registered holders from this group is bigger,
# then current holder is tainted
if groupHolders > maxGroupRestriction:
taintedHolders[holder] = MaxGroupErrorData(
maxGroup=maxGroupRestriction,
holderGroup=groupId,
groupHolders=groupHolders)
# Raise error if we detected any tainted holders
if taintedHolders:
raise RegisterValidationError(taintedHolders)
@property
def restrictionType(self):
return self.__restrictionType
def __init__(self):
# Container for skill holders
# Format: {holder id: {holders}}
self.__skillHolders = KeyedSet()
class LinkRegister:
"""
Keep track of links between holders, which is required for efficient
partial attribute recalculation.
Positional arguments:
tracker -- LinkTracker object, which uses this register
"""
def __init__(self, tracker):
# The fit we're keeping track of things for
self.__tracker = tracker
# Keep track of holders belonging to certain location
# Format: {location: {targetHolders}}
self.__affecteeLocation = KeyedSet()
# Keep track of holders belonging to certain location and group
# Format: {(location, group): {targetHolders}}
self.__affecteeLocationGroup = KeyedSet()
# Keep track of holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {targetHolders}}
self.__affecteeLocationSkill = KeyedSet()
# Keep track of affectors influencing all holders belonging to certain location
# Format: {location: {affectors}}
self.__affectorLocation = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and group
# Format: {(location, group): {affectors}}
self.__affectorLocationGroup = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {affectors}}
self.__affectorLocationSkill = KeyedSet()
# Keep track of affectors influencing holders directly
# Format: {targetHolder: {affectors}}
self.__activeDirectAffectors = KeyedSet()
# Keep track of affectors which influence locOther, but are disabled
# as their target location is not available
# Format: {sourceHolder: {affectors}}
self.__disabledDirectAffectors = KeyedSet()
def __getAffecteeMaps(self, targetHolder):
"""
Helper for affectee register/unregister methods.
Positional arguments:
targetHolder -- holder, for which affectee maps are requested
Return value:
List of (key, affecteeMap) tuples, where key should be used to access
data set (appropriate to passed targetHolder) in affecteeMap
"""
# Container which temporarily holds (key, map) tuples
affecteeMaps = []
location = targetHolder._location
if location is not None:
affecteeMaps.append((location, self.__affecteeLocation))
group = targetHolder.item.groupId
if group is not None:
affecteeMaps.append(((location, group), self.__affecteeLocationGroup))
for skill in targetHolder.item.requiredSkills:
affecteeMaps.append(((location, skill), self.__affecteeLocationSkill))
return affecteeMaps
def __getAffectorMap(self, affector):
"""
Helper for affector register/unregister methods.
Positional arguments:
affector -- affector, for which affector map are requested
Return value:
(key, affectorMap) tuple, where key should be used to access
data set (appropriate to passed affector) in affectorMap
Possible exceptions:
FilteredSelfReferenceError -- raised if affector's modifier specifies
filtered modification and target location refers self, but affector's
holder isn't in position to be target for filtered modifications
DirectLocationError -- raised when affector's modifier target
location is not supported for direct modification
FilteredLocationError -- raised when affector's modifier target
location is not supported for filtered modification
FilterTypeError -- raised when affector's modifier filter type is not
supported
"""
sourceHolder, modifier = affector
# For each filter type, define affector map and key to use
if modifier.filterType is None:
# For single item modifications, we need to properly pick
# target holder (it's key) based on location
if modifier.location == Location.self_:
affectorMap = self.__activeDirectAffectors
key = sourceHolder
elif modifier.location == Location.character:
char = self.__tracker._fit.character
if char is not None:
affectorMap = self.__activeDirectAffectors
key = char
else:
affectorMap = self.__disabledDirectAffectors
key = sourceHolder
elif modifier.location == Location.ship:
ship = self.__tracker._fit.ship
if ship is not None:
affectorMap = self.__activeDirectAffectors
key = ship
else:
affectorMap = self.__disabledDirectAffectors
key = sourceHolder
# When other location is referenced, it means direct reference to module's charge
# or to charge's module-container
elif modifier.location == Location.other:
try:
otherHolder = sourceHolder._other
except AttributeError:
otherHolder = None
if otherHolder is not None:
affectorMap = self.__activeDirectAffectors
key = otherHolder
# When no reference available, it means that e.g. charge may be
# unavailable for now; use disabled affectors map for these
else:
affectorMap = self.__disabledDirectAffectors
key = sourceHolder
else:
raise DirectLocationError(modifier.location)
# For massive modifications, compose key, making sure reference to self
# is converted into appropriate real location
elif modifier.filterType == FilterType.all_:
affectorMap = self.__affectorLocation
location = self.__contextizeFilterLocation(affector)
key = location
elif modifier.filterType == FilterType.group:
affectorMap = self.__affectorLocationGroup
location = self.__contextizeFilterLocation(affector)
key = (location, modifier.filterValue)
elif modifier.filterType == FilterType.skill:
affectorMap = self.__affectorLocationSkill
location = self.__contextizeFilterLocation(affector)
skill = self.__contextizeSkillrqId(affector)
key = (location, skill)
else:
raise FilterTypeError(modifier.filterType)
return key, affectorMap
def __contextizeFilterLocation(self, affector):
"""
Convert location self-reference to real location, like
character or ship. Used only in modifications of multiple
filtered holders, direct modifications are processed out
of the context of this method.
Positional arguments:
affector -- affector, whose modifier refers location in question
Return value:
Real contextized location
Possible exceptions:
FilteredSelfReferenceError -- raised if affector's modifier
refers self, but affector's holder isn't in position to be
target for massive filtered modifications
FilteredLocationError -- raised when affector's modifier
target location is not supported for filtered modification
"""
sourceHolder = affector.sourceHolder
targetLocation = affector.modifier.location
# Reference to self is sparingly used in ship effects, so we must convert
# it to real location
if targetLocation == Location.self_:
if sourceHolder is self.__tracker._fit.ship:
return Location.ship
elif sourceHolder is self.__tracker._fit.character:
return Location.character
else:
raise FilteredSelfReferenceError
# Just return untouched location for all other valid cases
elif targetLocation in (Location.character, Location.ship, Location.space):
return targetLocation
# Raise error if location is invalid
else:
raise FilteredLocationError(targetLocation)
def __contextizeSkillrqId(self, affector):
"""
Convert typeID self-reference into real typeID.
Positional arguments:
affector -- affector, whose modifier refers some type via ID
Return value:
Real typeID, taken from affector's holder carrier
"""
skillId = affector.modifier.filterValue
if skillId == InvType.self_:
skillId = affector.sourceHolder.item.id
return skillId
def __enableDirectSpec(self, targetHolder, targetLocation):
"""
Enable temporarily disabled affectors, directly targeting holder in
specific location.
Positional arguments:
targetHolder -- holder which is being registered
targetLocation -- location, to which holder is being registered
"""
affectorsToEnable = set()
# Cycle through all disabled direct affectors
for affectorSet in self.__disabledDirectAffectors.values():
for affector in affectorSet:
modifier = affector.modifier
# Mark affector as to-be-enabled only when it specifically
# targets passed target location, and not holders assigned
# to it
if modifier.location == targetLocation and modifier.filterType is None:
affectorsToEnable.add(affector)
# Bail if we have nothing to do
if not affectorsToEnable:
return
# Move all of them to direct modification dictionary
self.__activeDirectAffectors.addDataSet(targetHolder, affectorsToEnable)
self.__disabledDirectAffectors.rmDataSet(affector.sourceHolder, affectorsToEnable)
def __disableDirectSpec(self, targetHolder):
"""
Disable affectors, directly targeting holder in specific location.
Positional arguments:
targetHolder -- holder which is being unregistered
"""
affectorsToDisable = set()
# Check all affectors, targeting passed holder
for affector in self.__activeDirectAffectors.get(targetHolder) or ():
# Mark them as to-be-disabled only if they originate from
# other holder, else they should be removed with passed holder
if affector.sourceHolder is not targetHolder:
affectorsToDisable.add(affector)
if not affectorsToDisable:
return
# Move data from map to map
self.__disabledDirectAffectors.addDataSet(affector.sourceHolder, affectorsToDisable)
self.__activeDirectAffectors.rmDataSet(targetHolder, affectorsToDisable)
def __enableDirectOther(self, targetHolder):
"""
Enable temporarily disabled affectors, directly targeting passed holder,
originating from holder in "other" location.
Positional arguments:
targetHolder -- holder which is being registered
"""
try:
otherHolder = targetHolder._other
except AttributeError:
otherHolder = None
# If passed holder doesn't have other location (charge's module
# or module's charge), do nothing
if otherHolder is None:
return
# Get all disabled affectors which should influence our targetHolder
affectorsToEnable = set()
for affector in self.__disabledDirectAffectors.get(otherHolder) or ():
modifier = affector.modifier
if modifier.location == Location.other and modifier.filterType is None:
affectorsToEnable.add(affector)
# Bail if we have nothing to do
if not affectorsToEnable:
return
# Move all of them to direct modification dictionary
self.__activeDirectAffectors.addDataSet(targetHolder, affectorsToEnable)
self.__disabledDirectAffectors.rmDataSet(otherHolder, affectorsToEnable)
def __disableDirectOther(self, targetHolder):
"""
Disable affectors, directly targeting passed holder, originating from
holder in "other" location.
Positional arguments:
targetHolder -- holder which is being unregistered
"""
try:
otherHolder = targetHolder._other
except AttributeError:
otherHolder = None
if otherHolder is None:
return
affectorsToDisable = set()
# Go through all affectors influencing holder being unregistered
for affector in self.__activeDirectAffectors.get(targetHolder) or ():
# If affector originates from otherHolder, mark it as
# to-be-disabled
if affector.sourceHolder is otherHolder:
affectorsToDisable.add(affector)
# Do nothing if we have no such affectors
if not affectorsToDisable:
return
# If we have, move them from map to map
self.__disabledDirectAffectors.addDataSet(otherHolder, affectorsToDisable)
self.__activeDirectAffectors.rmDataSet(targetHolder, affectorsToDisable)
def registerAffectee(self, targetHolder, enableDirect=None):
"""
Add passed target holder to register's maps, so it can be affected by
other holders properly.
Positional arguments:
targetHolder -- holder to register
Keyword arguments:
enableDirect -- when some location specification is passed, register
checks if there're any modifications which should directly apply to
holder in that location (or, in case with "other" location, originate
from holder in that location and apply to passed targetHolder) and
enables them (default None)
"""
for key, affecteeMap in self.__getAffecteeMaps(targetHolder):
# Add data to map
affecteeMap.addData(key, targetHolder)
# Check if we have affectors which should directly influence passed holder,
# but are disabled
directEnablers = {Location.ship: (self.__enableDirectSpec, (targetHolder, Location.ship), {}),
Location.character: (self.__enableDirectSpec, (targetHolder, Location.character), {}),
Location.other: (self.__enableDirectOther, (targetHolder,), {})}
try:
method, args, kwargs = directEnablers[enableDirect]
except KeyError:
pass
else:
method(*args, **kwargs)
def unregisterAffectee(self, targetHolder, disableDirect=None):
"""
Remove passed target holder from register's maps, so holders affecting
it "know" that its modification is no longer needed.
Positional arguments:
targetHolder -- holder to unregister
Keyword arguments:
disableDirect -- when some location specification is passed, register
checks if there're any modifications which are directly applied to
holder in that location (or, in case with "other" location, originate
from holder in that location and apply to passed targetHolder) and
disables them (default None)
"""
for key, affecteeMap in self.__getAffecteeMaps(targetHolder):
affecteeMap.rmData(key, targetHolder)
# When removing holder from register, make sure to move modifiers which
# originate from other holders and directly affect it to disabled map
directEnablers = {Location.ship: (self.__disableDirectSpec, (targetHolder,), {}),
Location.character: (self.__disableDirectSpec, (targetHolder,), {}),
Location.other: (self.__disableDirectOther, (targetHolder,), {})}
try:
method, args, kwargs = directEnablers[disableDirect]
except KeyError:
pass
else:
method(*args, **kwargs)
def registerAffector(self, affector):
"""
Add passed affector to register's affector maps, so that new holders
added to fit know that they should be affected by it.
Positional arguments:
affector -- affector to register
"""
try:
key, affectorMap = self.__getAffectorMap(affector)
# Actually add data to map
affectorMap.addData(key, affector)
except DirectLocationError as e:
msg = "malformed modifier on item {}: unsupported target location {} for direct modification".format(affector.sourceHolder.item.id, e.args[0])
signature = (type(e), affector.sourceHolder.item.id, e.args[0])
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
except FilteredLocationError as e:
msg = "malformed modifier on item {}: unsupported target location {} for filtered modification".format(affector.sourceHolder.item.id, e.args[0])
signature = (type(e), affector.sourceHolder.item.id, e.args[0])
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
except FilteredSelfReferenceError as e:
msg = "malformed modifier on item {}: invalid reference to self for filtered modification".format(affector.sourceHolder.item.id)
signature = (type(e), affector.sourceHolder.item.id)
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
except FilterTypeError as e:
msg = "malformed modifier on item {}: invalid filter type {}".format(affector.sourceHolder.item.id, e.args[0])
signature = (type(e), affector.sourceHolder.item.id, e.args[0])
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
def unregisterAffector(self, affector):
"""
Remove passed affector from register's affector maps, so that
holders-affectees "know" that they're no longer affected by it.
Positional arguments:
affector -- affector to unregister
"""
try:
key, affectorMap = self.__getAffectorMap(affector)
affectorMap.rmData(key, affector)
# Following block handles exceptions; all of them must be handled
# when registering affector too, thus they won't appear in log
# if logger's handler suppresses messages with duplicate
# signature
except DirectLocationError as e:
msg = "malformed modifier on item {}: unsupported target location {} for direct modification".format(affector.sourceHolder.item.id, e.args[0])
signature = (type(e), affector.sourceHolder.item.id, e.args[0])
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
except FilteredLocationError as e:
msg = "malformed modifier on item {}: unsupported target location {} for filtered modification".format(affector.sourceHolder.item.id, e.args[0])
signature = (type(e), affector.sourceHolder.item.id, e.args[0])
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
except FilteredSelfReferenceError as e:
msg = "malformed modifier on item {}: invalid reference to self for filtered modification".format(affector.sourceHolder.item.id)
signature = (type(e), affector.sourceHolder.item.id)
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
except FilterTypeError as e:
msg = "malformed modifier on item {}: invalid filter type {}".format(affector.sourceHolder.item.id, e.args[0])
signature = (type(e), affector.sourceHolder.item.id, e.args[0])
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
def getAffectees(self, affector):
"""
Get all holders influenced by passed affector.
Positional arguments:
affector -- affector, for which we're seeking for affectees
Return value:
Set with holders, being influenced by affector
"""
sourceHolder, modifier = affector
affectees = set()
try:
# For direct modification, make set out of single target location
if modifier.filterType is None:
if modifier.location == Location.self_:
target = {sourceHolder}
elif modifier.location == Location.character:
char = self.__tracker._fit.character
target = {char} if char is not None else None
elif modifier.location == Location.ship:
ship = self.__tracker._fit.ship
target = {ship} if ship is not None else None
elif modifier.location == Location.other:
try:
otherHolder = sourceHolder._other
except AttributeError:
otherHolder = None
target = {otherHolder} if otherHolder is not None else None
else:
raise DirectLocationError(modifier.location)
# For filtered modifications, pick appropriate dictionary and get set
# with target holders
elif modifier.filterType == FilterType.all_:
key = self.__contextizeFilterLocation(affector)
target = self.__affecteeLocation.get(key) or set()
elif modifier.filterType == FilterType.group:
location = self.__contextizeFilterLocation(affector)
key = (location, modifier.filterValue)
target = self.__affecteeLocationGroup.get(key) or set()
elif modifier.filterType == FilterType.skill:
location = self.__contextizeFilterLocation(affector)
skill = self.__contextizeSkillrqId(affector)
key = (location, skill)
target = self.__affecteeLocationSkill.get(key) or set()
else:
raise FilterTypeError(modifier.filterType)
# Add our set to affectees
if target is not None:
affectees.update(target)
# If passed affector has already been registered and logger prefers
# to suppress messages with duplicate signatures, following error handling
# won't produce new log entries
except DirectLocationError as e:
msg = "malformed modifier on item {}: unsupported target location {} for direct modification".format(sourceHolder.item.id, e.args[0])
signature = (type(e), sourceHolder.item.id, e.args[0])
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
except FilteredLocationError as e:
msg = "malformed modifier on item {}: unsupported target location {} for filtered modification".format(sourceHolder.item.id, e.args[0])
signature = (type(e), sourceHolder.item.id, e.args[0])
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
except FilteredSelfReferenceError as e:
msg = "malformed modifier on item {}: invalid reference to self for filtered modification".format(sourceHolder.item.id)
signature = (type(e), sourceHolder.item.id)
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
except FilterTypeError as e:
msg = "malformed modifier on item {}: invalid filter type {}".format(sourceHolder.item.id, e.args[0])
signature = (type(e), sourceHolder.item.id, e.args[0])
self.__tracker._fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
return affectees
def getAffectors(self, targetHolder):
"""
Get all affectors, which influence passed holder.
Positional arguments:
targetHolder -- holder, for which we're seeking for affecting it
affectors
Return value:
Set with affectors, incluencing targetHolder
"""
affectors = set()
# Add all affectors which directly affect it
affectors.update(self.__activeDirectAffectors.get(targetHolder) or set())
# Then all affectors which affect location of passed holder
location = targetHolder._location
affectors.update(self.__affectorLocation.get(location) or set())
# All affectors which affect location and group of passed holder
group = targetHolder.item.groupId
affectors.update(self.__affectorLocationGroup.get((location, group)) or set())
# Same, but for location & skill requirement of passed holder
for skill in targetHolder.item.requiredSkills:
affectors.update(self.__affectorLocationSkill.get((location, skill)) or set())
return affectors
class LinkRegister:
"""
Keep track of currently existing links between affectors
(Affector objects) and affectees (holders). This is hard
requirement for efficient partial attribute recalculation.
Register is not aware of links between specific attributes,
doesn't know anything about states and contexts, just
affectors and affectees.
Positional arguments:
fit -- fit, to which this register is bound to
"""
def __init__(self, fit):
# Link tracker which is assigned to fit we're
# keeping data for
self._fit = fit
# Keep track of holders belonging to certain location
# Format: {location: {targetHolders}}
self.__affecteeLocation = KeyedSet()
# Keep track of holders belonging to certain location and group
# Format: {(location, group): {targetHolders}}
self.__affecteeLocationGroup = KeyedSet()
# Keep track of holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {targetHolders}}
self.__affecteeLocationSkill = KeyedSet()
# Keep track of affectors influencing all holders belonging to certain location
# Format: {location: {affectors}}
self.__affectorLocation = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and group
# Format: {(location, group): {affectors}}
self.__affectorLocationGroup = KeyedSet()
# Keep track of affectors influencing holders belonging to certain location and having certain skill requirement
# Format: {(location, skill): {affectors}}
self.__affectorLocationSkill = KeyedSet()
# Keep track of affectors influencing holders directly
# Format: {targetHolder: {affectors}}
self.__activeDirectAffectors = KeyedSet()
# Keep track of affectors which influence something directly,
# but are disabled as their target location is not available
# Format: {sourceHolder: {affectors}}
self.__disabledDirectAffectors = KeyedSet()
def registerAffectee(self, targetHolder):
"""
Add passed target holder to register's maps, so it can be affected by
other holders properly.
Positional arguments:
targetHolder -- holder to register
"""
for key, affecteeMap in self.__getAffecteeMaps(targetHolder):
# Add data to map
affecteeMap.addData(key, targetHolder)
# Check if we have affectors which should directly influence passed holder,
# but are disabled; enable them if there're any
enableDirect = self.__getHolderDirectLocation(targetHolder)
if enableDirect is None:
return
if enableDirect == Location.other:
self.__enableDirectOther(targetHolder)
elif enableDirect in (Location.character, Location.ship):
self.__enableDirectSpec(targetHolder, enableDirect)
def unregisterAffectee(self, targetHolder):
"""
Remove passed target holder from register's maps, so holders affecting
it "know" that its modification is no longer needed.
Positional arguments:
targetHolder -- holder to unregister
"""
for key, affecteeMap in self.__getAffecteeMaps(targetHolder):
affecteeMap.rmData(key, targetHolder)
# When removing holder from register, make sure to move modifiers which
# originate from 'other' holders and directly affect it to disabled map
disableDirect = self.__getHolderDirectLocation(targetHolder)
if disableDirect is None:
return
if disableDirect is None:
return
if disableDirect == Location.other:
self.__disableDirectOther(targetHolder)
elif disableDirect in (Location.character, Location.ship):
self.__disableDirectSpec(targetHolder)
def registerAffector(self, affector):
"""
Add passed affector to register's affector maps, so that new holders
added to fit know that they should be affected by it.
Positional arguments:
affector -- affector to register
"""
try:
key, affectorMap = self.__getAffectorMap(affector)
# Actually add data to map
affectorMap.addData(key, affector)
except Exception as e:
self.__handleAffectorErrors(e, affector)
def unregisterAffector(self, affector):
"""
Remove passed affector from register's affector maps, so that
holders-affectees "know" that they're no longer affected by it.
Positional arguments:
affector -- affector to unregister
"""
try:
key, affectorMap = self.__getAffectorMap(affector)
affectorMap.rmData(key, affector)
# Following block handles exceptions; all of them must be handled
# when registering affector too, thus they won't appear in log
# if logger's handler suppresses messages with duplicate
# signature
except Exception as e:
self.__handleAffectorErrors(e, affector)
def getAffectees(self, affector):
"""
Get all holders influenced by passed affector.
Positional arguments:
affector -- affector, for which we're seeking for affectees
Return value:
Set with holders, being influenced by affector
"""
sourceHolder, modifier = affector
affectees = set()
try:
# For direct modification, make set out of single target location
if modifier.filterType is None:
if modifier.location == Location.self_:
target = {sourceHolder}
elif modifier.location == Location.character:
char = self._fit.character
target = {char} if char is not None else None
elif modifier.location == Location.ship:
ship = self._fit.ship
target = {ship} if ship is not None else None
elif modifier.location == Location.other:
try:
otherHolder = sourceHolder._other
except AttributeError:
otherHolder = None
target = {otherHolder} if otherHolder is not None else None
else:
raise DirectLocationError(modifier.location)
# For filtered modifications, pick appropriate dictionary and get set
# with target holders
elif modifier.filterType == FilterType.all_:
key = self.__contextizeFilterLocation(affector)
target = self.__affecteeLocation.get(key) or set()
elif modifier.filterType == FilterType.group:
location = self.__contextizeFilterLocation(affector)
key = (location, modifier.filterValue)
target = self.__affecteeLocationGroup.get(key) or set()
elif modifier.filterType == FilterType.skill:
location = self.__contextizeFilterLocation(affector)
skill = affector.modifier.filterValue
key = (location, skill)
target = self.__affecteeLocationSkill.get(key) or set()
elif modifier.filterType == FilterType.skillSelf:
location = self.__contextizeFilterLocation(affector)
skill = affector.sourceHolder.item.id
key = (location, skill)
target = self.__affecteeLocationSkill.get(key) or set()
else:
raise FilterTypeError(modifier.filterType)
# Add our set to affectees
if target is not None:
affectees.update(target)
# If passed affector has already been registered and logger prefers
# to suppress messages with duplicate signatures, following error handling
# won't produce new log entries
except Exception as e:
self.__handleAffectorErrors(e, affector)
return affectees
def getAffectors(self, targetHolder):
"""
Get all affectors, which influence passed holder.
Positional arguments:
targetHolder -- holder, for which we're seeking for affecting it
affectors
Return value:
Set with affectors, incluencing targetHolder
"""
affectors = set()
# Add all affectors which directly affect it
affectors.update(
self.__activeDirectAffectors.get(targetHolder) or set())
# Then all affectors which affect location of passed holder
location = targetHolder._location
affectors.update(self.__affectorLocation.get(location) or set())
# All affectors which affect location and group of passed holder
group = targetHolder.item.groupId
affectors.update(
self.__affectorLocationGroup.get((location, group)) or set())
# Same, but for location & skill requirement of passed holder
for skill in targetHolder.item.requiredSkills:
affectors.update(
self.__affectorLocationSkill.get((location, skill)) or set())
return affectors
# General-purpose auxiliary methods
def __getAffecteeMaps(self, targetHolder):
"""
Helper for affectee register/unregister methods.
Positional arguments:
targetHolder -- holder, for which affectee maps are requested
Return value:
List of (key, affecteeMap) tuples, where key should be used to access
data set (appropriate to passed targetHolder) in affecteeMap
"""
# Container which temporarily holds (key, map) tuples
affecteeMaps = []
location = targetHolder._location
if location is not None:
affecteeMaps.append((location, self.__affecteeLocation))
group = targetHolder.item.groupId
if group is not None:
affecteeMaps.append(
((location, group), self.__affecteeLocationGroup))
for skill in targetHolder.item.requiredSkills:
affecteeMaps.append(
((location, skill), self.__affecteeLocationSkill))
return affecteeMaps
def __getAffectorMap(self, affector):
"""
Helper for affector register/unregister methods.
Positional arguments:
affector -- affector, for which affector map are requested
Return value:
(key, affectorMap) tuple, where key should be used to access
data set (appropriate to passed affector) in affectorMap
Possible exceptions:
FilteredSelfReferenceError -- raised if affector's modifier specifies
filtered modification and target location refers self, but affector's
holder isn't in position to be target for filtered modifications
DirectLocationError -- raised when affector's modifier target
location is not supported for direct modification
FilteredLocationError -- raised when affector's modifier target
location is not supported for filtered modification
FilterTypeError -- raised when affector's modifier filter type is not
supported
"""
sourceHolder, modifier = affector
# For each filter type, define affector map and key to use
if modifier.filterType is None:
# For direct modifications, we need to properly pick
# target holder (it's key) based on location
if modifier.location == Location.self_:
affectorMap = self.__activeDirectAffectors
key = sourceHolder
elif modifier.location == Location.character:
char = self._fit.character
if char is not None:
affectorMap = self.__activeDirectAffectors
key = char
else:
affectorMap = self.__disabledDirectAffectors
key = sourceHolder
elif modifier.location == Location.ship:
ship = self._fit.ship
if ship is not None:
affectorMap = self.__activeDirectAffectors
key = ship
else:
affectorMap = self.__disabledDirectAffectors
key = sourceHolder
# When other location is referenced, it means direct reference to module's charge
# or to charge's module-container
elif modifier.location == Location.other:
try:
otherHolder = sourceHolder._other
except AttributeError:
otherHolder = None
if otherHolder is not None:
affectorMap = self.__activeDirectAffectors
key = otherHolder
# When no reference available, it means that e.g. charge may be
# unavailable for now; use disabled affectors map for these
else:
affectorMap = self.__disabledDirectAffectors
key = sourceHolder
else:
raise DirectLocationError(modifier.location)
# For filtered modifications, compose key, making sure reference to self
# is converted into appropriate real location
elif modifier.filterType == FilterType.all_:
affectorMap = self.__affectorLocation
location = self.__contextizeFilterLocation(affector)
key = location
elif modifier.filterType == FilterType.group:
affectorMap = self.__affectorLocationGroup
location = self.__contextizeFilterLocation(affector)
key = (location, modifier.filterValue)
elif modifier.filterType == FilterType.skill:
affectorMap = self.__affectorLocationSkill
location = self.__contextizeFilterLocation(affector)
skill = affector.modifier.filterValue
key = (location, skill)
elif modifier.filterType == FilterType.skillSelf:
affectorMap = self.__affectorLocationSkill
location = self.__contextizeFilterLocation(affector)
skill = affector.sourceHolder.item.id
key = (location, skill)
else:
raise FilterTypeError(modifier.filterType)
return key, affectorMap
def __handleAffectorErrors(self, error, affector):
"""
Multiple register methods which get data based on passed affector
raise similar exception classes. To handle them in consistent fashion,
it is done from centralized place - this method. If error cannot be
handled by method, it is re-raised.
Positional arguments:
error -- Exception instance which was caught and needs to be handled
affector -- affector object, which was being processed when error occurred
"""
if isinstance(error, DirectLocationError):
msg = 'malformed modifier on item {}: unsupported target location {} for direct modification'.format(
affector.sourceHolder.item.id, error.args[0])
signature = (type(error), affector.sourceHolder.item.id,
error.args[0])
self._fit.eos._logger.warning(msg,
childName='attributeCalculator',
signature=signature)
elif isinstance(error, FilteredLocationError):
msg = 'malformed modifier on item {}: unsupported target location {} for filtered modification'.format(
affector.sourceHolder.item.id, error.args[0])
signature = (type(error), affector.sourceHolder.item.id,
error.args[0])
self._fit.eos._logger.warning(msg,
childName='attributeCalculator',
signature=signature)
elif isinstance(error, FilteredSelfReferenceError):
msg = 'malformed modifier on item {}: invalid reference to self for filtered modification'.format(
affector.sourceHolder.item.id)
signature = (type(error), affector.sourceHolder.item.id)
self._fit.eos._logger.warning(msg,
childName='attributeCalculator',
signature=signature)
elif isinstance(error, FilterTypeError):
msg = 'malformed modifier on item {}: invalid filter type {}'.format(
affector.sourceHolder.item.id, error.args[0])
signature = (type(error), affector.sourceHolder.item.id,
error.args[0])
self._fit.eos._logger.warning(msg,
childName='attributeCalculator',
signature=signature)
else:
raise error
# Methods which help to process filtered modifications
def __contextizeFilterLocation(self, affector):
"""
Convert location self-reference to real location, like
character or ship. Used only in modifications of multiple
filtered holders, direct modifications are processed out
of the context of this method.
Positional arguments:
affector -- affector, whose modifier refers location in question
Return value:
Real contextized location
Possible exceptions:
FilteredSelfReferenceError -- raised if affector's modifier
refers self, but affector's holder isn't in position to be
target for filtered modifications
FilteredLocationError -- raised when affector's modifier
target location is not supported for filtered modification
"""
sourceHolder = affector.sourceHolder
targetLocation = affector.modifier.location
# Reference to self is sparingly used in ship effects, so we must convert
# it to real location
if targetLocation == Location.self_:
if sourceHolder is self._fit.ship:
return Location.ship
elif sourceHolder is self._fit.character:
return Location.character
else:
raise FilteredSelfReferenceError
# Just return untouched location for all other valid cases
elif targetLocation in (Location.character, Location.ship,
Location.space):
return targetLocation
# Raise error if location is invalid
else:
raise FilteredLocationError(targetLocation)
# Methods which help to process direct modifications
def __getHolderDirectLocation(self, holder):
"""
Get location which you need to target to apply
direct modification to passed holder.
Positional arguments:
holder -- holder in question
Return value:
Location specification, if holder can be targeted directly
from the outside, or None if it can't
"""
# For ship and character it's easy, we're just picking
# corresponding location
if holder is self._fit.ship:
location = Location.ship
elif holder is self._fit.character:
location = Location.character
# For "other" location, we should've checked for presence
# of other entity - charge's container or module's charge
elif getattr(holder, '_other', None) is not None:
location = Location.other
else:
location = None
return location
def __enableDirectSpec(self, targetHolder, targetLocation):
"""
Enable temporarily disabled affectors, directly targeting holder in
specific location.
Positional arguments:
targetHolder -- holder which is being registered
targetLocation -- location, to which holder is being registered
"""
# Format: {sourceHolder: [affectors]}
affectorsToEnable = {}
# Cycle through all disabled direct affectors
for sourceHolder, affectorSet in self.__disabledDirectAffectors.items(
):
for affector in affectorSet:
modifier = affector.modifier
# Mark affector as to-be-enabled only when it
# targets passed target location
if modifier.location == targetLocation:
sourceAffectors = affectorsToEnable.setdefault(
sourceHolder, [])
sourceAffectors.append(affector)
# Bail if we have nothing to do
if not affectorsToEnable:
return
# Move all of them to direct modification dictionary
for sourceHolder, affectors in affectorsToEnable.items():
self.__disabledDirectAffectors.rmDataSet(sourceHolder, affectors)
self.__activeDirectAffectors.addDataSet(targetHolder, affectors)
def __disableDirectSpec(self, targetHolder):
"""
Disable affectors, directly targeting holder in specific location.
Positional arguments:
targetHolder -- holder which is being unregistered
"""
# Format: {sourceHolder: [affectors]}
affectorsToDisable = {}
# Check all affectors, targeting passed holder
for affector in self.__activeDirectAffectors.get(targetHolder) or ():
# Mark them as to-be-disabled only if they originate from
# other holder, else they should be removed with passed holder
if affector.sourceHolder is not targetHolder:
sourceAffectors = affectorsToDisable.setdefault(
affector.sourceHolder, [])
sourceAffectors.append(affector)
if not affectorsToDisable:
return
# Move data from map to map
for sourceHolder, affectors in affectorsToDisable.items():
self.__activeDirectAffectors.rmDataSet(targetHolder, affectors)
self.__disabledDirectAffectors.addDataSet(sourceHolder, affectors)
def __enableDirectOther(self, targetHolder):
"""
Enable temporarily disabled affectors, directly targeting passed holder,
originating from holder in "other" location.
Positional arguments:
targetHolder -- holder which is being registered
"""
try:
otherHolder = targetHolder._other
except AttributeError:
otherHolder = None
# If passed holder doesn't have other location (charge's module
# or module's charge), do nothing
if otherHolder is None:
return
# Get all disabled affectors which should influence our targetHolder
affectorsToEnable = set()
for affector in self.__disabledDirectAffectors.get(otherHolder) or ():
modifier = affector.modifier
if modifier.location == Location.other:
affectorsToEnable.add(affector)
# Bail if we have nothing to do
if not affectorsToEnable:
return
# Move all of them to direct modification dictionary
self.__activeDirectAffectors.addDataSet(targetHolder,
affectorsToEnable)
self.__disabledDirectAffectors.rmDataSet(otherHolder,
affectorsToEnable)
def __disableDirectOther(self, targetHolder):
"""
Disable affectors, directly targeting passed holder, originating from
holder in "other" location.
Positional arguments:
targetHolder -- holder which is being unregistered
"""
try:
otherHolder = targetHolder._other
except AttributeError:
otherHolder = None
if otherHolder is None:
return
affectorsToDisable = set()
# Go through all affectors influencing holder being unregistered
for affector in self.__activeDirectAffectors.get(targetHolder) or ():
# If affector originates from otherHolder, mark it as
# to-be-disabled
if affector.sourceHolder is otherHolder:
affectorsToDisable.add(affector)
# Do nothing if we have no such affectors
if not affectorsToDisable:
return
# If we have, move them from map to map
self.__disabledDirectAffectors.addDataSet(otherHolder,
affectorsToDisable)
self.__activeDirectAffectors.rmDataSet(targetHolder,
affectorsToDisable)
class MutableAttributeMap:
"""
Calculate, store and provide access to modified attribute values.
Positional arguments:
holder -- holder, to which this map is assigned
"""
__slots__ = ('__holder', '__modifiedAttributes', '_capMap')
def __init__(self, holder):
# Reference to holder for internal needs
self.__holder = holder
# Actual container of calculated attributes
# Format: {attribute ID: value}
self.__modifiedAttributes = {}
# This variable stores map of attributes which cap
# something, and attributes capped by them. Initialized
# to None to not waste memory, will be changed to dict
# when needed.
# Format {capping attribute ID: {capped attribute IDs}}
self._capMap = None
def __getitem__(self, attrId):
# Special handling for skill level attribute
if attrId == Attribute.skillLevel:
# Attempt to return level attribute of holder
try:
val = self.__holder.level
# Try regular way of getting attribute, if accessing
# level attribute failed
except AttributeError:
pass
else:
return val
# If carrier holder isn't assigned to any fit, then
# we can use just item's original attributes
if self.__holder._fit is None:
val = self.__holder.item.attributes[attrId]
return val
# If value is stored, it's considered valid
try:
val = self.__modifiedAttributes[attrId]
# Else, we have to run full calculation process
except KeyError:
try:
val = self.__modifiedAttributes[attrId] = self.__calculate(
attrId)
except BaseValueError as e:
msg = 'unable to find base value for attribute {} on item {}'.format(
e.args[0], self.__holder.item.id)
signature = (type(e), self.__holder.item.id, e.args[0])
self.__holder._fit.eos._logger.warning(
msg, childName='attributeCalculator', signature=signature)
raise KeyError(attrId) from e
except AttributeMetaError as e:
msg = 'unable to fetch metadata for attribute {}, requested for item {}'.format(
e.args[0], self.__holder.item.id)
signature = (type(e), self.__holder.item.id, e.args[0])
self.__holder._fit.eos._logger.error(
msg, childName='attributeCalculator', signature=signature)
raise KeyError(attrId) from e
self.__holder._fit._linkTracker.clearHolderAttributeDependents(
self.__holder, attrId)
return val
def __len__(self):
return len(self.keys())
def __contains__(self, attrId):
# Seek for attribute in both modified attribute container
# and original item attributes
result = attrId in self.__modifiedAttributes or attrId in self.__holder.item.attributes
return result
def __iter__(self):
for k in self.keys():
yield k
def __delitem__(self, attrId):
# Clear the value in our calculated attributes dictionary
try:
del self.__modifiedAttributes[attrId]
# Do nothing if it wasn't calculated
except KeyError:
pass
# And make sure all other attributes relying on it
# are cleared too
else:
self.__holder._fit._linkTracker.clearHolderAttributeDependents(
self.__holder, attrId)
def __setitem__(self, attrId, value):
# Write value and clear all attributes relying on it
self.__modifiedAttributes[attrId] = value
self.__holder._fit._linkTracker.clearHolderAttributeDependents(
self.__holder, attrId)
def get(self, attrId, default=None):
try:
return self[attrId]
except KeyError:
return default
def keys(self):
# Return union of both keys which are already calculated in
return self.__modifiedAttributes.keys(
) | self.__holder.item.attributes.keys()
def clear(self):
"""Reset map to its initial state."""
self.__modifiedAttributes.clear()
self._capMap = None
def __calculate(self, attrId):
"""
Run calculations to find the actual value of attribute.
Positional arguments:
attrId -- ID of attribute to be calculated
Return value:
Calculated attribute value
Possible exceptions:
BaseValueError -- attribute cannot be calculated, as its
base value is not available
"""
# Attribute object for attribute being calculated
try:
attrMeta = self.__holder._fit.eos._cacheHandler.getAttribute(
attrId)
# Raise error if we can't get to getAttribute method
# or it can't find requested attribute
except (AttributeError, AttributeFetchError) as e:
raise AttributeMetaError(attrId) from e
# Base attribute value which we'll use for modification
try:
result = self.__holder.item.attributes[attrId]
# If attribute isn't available on base item,
# base off its default value
except KeyError:
result = attrMeta.defaultValue
# If original attribute is not specified and default
# value isn't available, raise error - without valid
# base we can't go on
if result is None:
raise BaseValueError(attrId)
# Container for non-penalized modifiers
# Format: {operator: [values]}
normalMods = {}
# Container for penalized modifiers
# Format: {operator: [values]}
penalizedMods = {}
# Now, go through all affectors affecting our holder
for affector in self.__holder._fit._linkTracker.getAffectors(
self.__holder, attrId=attrId):
try:
sourceHolder, modifier = affector
operator = modifier.operator
# Decide if it should be stacking penalized or not, based on stackable property,
# source item category and operator
penalize = (attrMeta.stackable is False
and sourceHolder.item.categoryId
not in penaltyImmuneCategories
and operator in penalizableOperators)
try:
modValue = sourceHolder.attributes[
modifier.sourceAttributeId]
# Silently skip current affector: error should already
# be logged by map before it raised KeyError
except KeyError:
continue
# Normalize operations to just three types:
# assignments, additions, multiplications
try:
normalizationFunc = normalizationMap[operator]
# Raise error on any unknown operator types
except KeyError as e:
raise OperatorError(operator) from e
modValue = normalizationFunc(modValue)
# Add value to appropriate dictionary
if penalize is True:
modList = penalizedMods.setdefault(operator, [])
else:
modList = normalMods.setdefault(operator, [])
modList.append(modValue)
# Handle operator type failure
except OperatorError as e:
msg = 'malformed modifier on item {}: unknown operator {}'.format(
sourceHolder.item.id, e.args[0])
signature = (type(e), sourceHolder.item.id, e.args[0])
self.__holder._fit.eos._logger.warning(
msg, childName='attributeCalculator', signature=signature)
continue
# When data gathering is complete, process penalized modifiers
# They are penalized on per-operator basis
for operator, modList in penalizedMods.items():
penalizedValue = self.__penalizeValues(modList)
modList = normalMods.setdefault(operator, [])
modList.append(penalizedValue)
# Calculate result of normal dictionary, according to operator order
for operator in sorted(normalMods):
modList = normalMods[operator]
# Pick best modifier for assignments, based on highIsGood value
if operator in assignments:
result = max(modList) if attrMeta.highIsGood is True else min(
modList)
elif operator in additions:
for modVal in modList:
result += modVal
elif operator in multiplications:
for modVal in modList:
result *= modVal
# If attribute has upper cap, do not let
# its value to grow above it
if attrMeta.maxAttributeId is not None:
try:
maxValue = self[attrMeta.maxAttributeId]
# If max value isn't available, don't
# cap anything
except KeyError:
pass
else:
result = min(result, maxValue)
# Let map know that capping attribute
# restricts current attribute
if self._capMap is None:
self._capMap = KeyedSet()
# Fill cap map with data: capping attribute and capped attribute
self._capMap.addData(attrMeta.maxAttributeId, attrId)
return result
def __penalizeValues(self, modList):
"""
Calculate aggregated factor of passed factors, taking into
consideration stacking penalty.
Positional argument:
modList -- list of factors
Return value:
Final aggregated factor of passed modList
"""
# Gather positive modifiers into one chain, negative
# into another
chainPositive = []
chainNegative = []
for modVal in modList:
# Transform value into form of multiplier - 1 for ease of
# stacking chain calculation
modVal -= 1
if modVal >= 0:
chainPositive.append(modVal)
else:
chainNegative.append(modVal)
# Strongest modifiers always go first
chainPositive.sort(reverse=True)
chainNegative.sort()
# Base final multiplier on 1
listResult = 1
for chain in (chainPositive, chainNegative):
# Same for intermediate per-chain result
chainResult = 1
for position, modifier in enumerate(chain):
# Ignore 12th modifier and further as non-significant
if position > 10:
break
# Apply stacking penalty based on modifier position
chainResult *= 1 + modifier * penaltyBase**(position**2)
listResult *= chainResult
return listResult
class SkillRequirementRegister(RestrictionRegister):
"""
Implements restriction:
To use holder, all its skill requirements must be met.
Details:
Only holders having level attribute are tracked.
Original item attributes are taken to determine skill and
skill level requirements.
If corresponding skill is found, but its skill level is None,
check for holder is failed.
"""
def __init__(self):
# Container for skill holders, for ease of
# access
# Format: {holder id: {holders}}
self.__skillHolders = KeyedSet()
# Set with holders which have any skill requirements
# Format: {holders}
self.__restrictedHolders = set()
def registerHolder(self, holder):
# Only holders which belong to character and have
# level attribute are tracked as skills
if hasattr(holder, "level") is True:
self.__skillHolders.addData(holder.item.id, holder)
# Holders which have any skill requirement are tracked
if holder.item.requiredSkills:
self.__restrictedHolders.add(holder)
def unregisterHolder(self, holder):
self.__skillHolders.rmData(holder.item.id, holder)
self.__restrictedHolders.discard(holder)
def validate(self):
taintedHolders = {}
# Go through restricted holders
for holder in self.__restrictedHolders:
# Container for skill requirement errors
skillRequirementErrors = []
# Check each skill requirement
for requiredSkillId in holder.item.requiredSkills:
requiredSkillLevel = holder.item.requiredSkills[requiredSkillId]
skillHolders = self.__skillHolders.get(requiredSkillId) or ()
# Pick max level of all skill holders, absence of skill
# is considered as skill level set to None
skillLevel = None
for skillHolder in skillHolders:
skillHolderLevel = skillHolder.level
if skillLevel is None:
skillLevel = skillHolderLevel
elif skillHolderLevel is not None:
skillLevel = max(skillLevel, skillHolderLevel)
# Last check - if skill level is lower than expected, current holder
# is tainted; mark it so and move to the next one
if skillLevel is None or skillLevel < requiredSkillLevel:
skillRequirementError = SkillRequirementErrorData(skill=requiredSkillId,
level=skillLevel,
requiredLevel=requiredSkillLevel)
skillRequirementErrors.append(skillRequirementError)
if skillRequirementErrors:
taintedHolders[holder] = tuple(skillRequirementErrors)
if taintedHolders:
raise RegisterValidationError(taintedHolders)
@property
def restrictionType(self):
return Restriction.skillRequirement
def __calculate(self, attrId):
"""
Run calculations to find the actual value of attribute.
Positional arguments:
attrId -- ID of attribute to be calculated
Return value:
Calculated attribute value
Possible exceptions:
BaseValueError -- attribute cannot be calculated, as its
base value is not available
"""
# Attribute object for attribute being calculated
try:
attrMeta = self.__holder.item._cacheHandler.getAttribute(attrId)
# Raise error if we can't get to getAttribute method
# or it can't find requested attribute
except (AttributeError, AttributeFetchError) as e:
raise AttributeMetaError(attrId) from e
# Base attribute value which we'll use for modification
try:
result = self.__holder.item.attributes[attrId]
# If attribute isn't available on base item,
# base off its default value
except KeyError:
result = attrMeta.defaultValue
# If original attribute is not specified and default
# value isn't available, raise error - without valid
# base we can't go on
if result is None:
raise BaseValueError(attrId)
# Container for non-penalized modifiers
# Format: {operator: [values]}
normalMods = {}
# Container for penalized modifiers
# Format: {operator: [values]}
penalizedMods = {}
# Now, go through all affectors affecting our holder
for affector in self.__holder.fit._linkTracker.getAffectors(self.__holder, attrId=attrId):
try:
sourceHolder, modifier = affector
operator = modifier.operator
# Decide if it should be stacking penalized or not, based on stackable property,
# source item category and operator
penalize = (attrMeta.stackable is False and not sourceHolder.item.categoryId in penaltyImmuneCategories
and operator in penalizableOperators)
try:
modValue = sourceHolder.attributes[modifier.sourceAttributeId]
# Silently skip current affector: error should already
# be logged by map before it raised KeyError
except KeyError:
continue
# Normalize operations to just three types:
# assignments, additions, multiplications
try:
normalizationFunc = normalizationMap[operator]
# Raise error on any unknown operator types
except KeyError as e:
raise OperatorError(operator) from e
modValue = normalizationFunc(modValue)
# Add value to appropriate dictionary
if penalize is True:
try:
modList = penalizedMods[operator]
except KeyError:
modList = penalizedMods[operator] = []
else:
try:
modList = normalMods[operator]
except KeyError:
modList = normalMods[operator] = []
modList.append(modValue)
# Handle operator type failure
except OperatorError as e:
msg = "malformed modifier on item {}: unknown operator {}".format(sourceHolder.item.id, e.args[0])
signature = (type(e), sourceHolder.item.id, e.args[0])
self.__holder.fit._eos._logger.warning(msg, childName="attributeCalculator", signature=signature)
continue
# When data gathering is complete, process penalized modifiers
# They are penalized on per-operator basis
for operator, modList in penalizedMods.items():
penalizedValue = self.__penalizeValues(modList)
try:
modList = normalMods[operator]
except KeyError:
modList = normalMods[operator] = []
modList.append(penalizedValue)
# Calculate result of normal dictionary, according to operator order
for operator in sorted(normalMods):
modList = normalMods[operator]
# Pick best modifier for assignments, based on highIsGood value
if operator in assignments:
result = max(modList) if attrMeta.highIsGood is True else min(modList)
elif operator in additions:
for modVal in modList:
result += modVal
elif operator in multiplications:
for modVal in modList:
result *= modVal
# If attribute has upper cap, do not let
# its value to grow above it
if attrMeta.maxAttributeId is not None:
try:
maxValue = self[attrMeta.maxAttributeId]
# If max value isn't available, don't
# cap anything
except KeyError:
pass
else:
result = min(result, maxValue)
# Let map know that capping attribute
# restricts current attribute
if self._capMap is None:
self._capMap = KeyedSet()
# Fill cap map with data: capping attribute and capped attribute
self._capMap.addData(attrMeta.maxAttributeId, attrId)
return result
class SkillRequirementRegister(RestrictionRegister):
"""
Implements restriction:
To use holder, all its skill requirements must be met.
Details:
Only holders having level attribute are tracked.
Original item attributes are taken to determine skill and
skill level requirements.
If corresponding skill is found, but its skill level is None,
check for holder is failed.
"""
def __init__(self):
# Container for skill holders, for ease of
# access
# Format: {holder id: {holders}}
self.__skillHolders = KeyedSet()
# Set with holders which have any skill requirements
# Format: {holders}
self.__restrictedHolders = set()
def registerHolder(self, holder):
# Only holders which belong to character and have
# level attribute are tracked as skills
if hasattr(holder, 'level') is True:
self.__skillHolders.addData(holder.item.id, holder)
# Holders which have any skill requirement are tracked
if holder.item.requiredSkills:
self.__restrictedHolders.add(holder)
def unregisterHolder(self, holder):
self.__skillHolders.rmData(holder.item.id, holder)
self.__restrictedHolders.discard(holder)
def validate(self):
taintedHolders = {}
# Go through restricted holders
for holder in self.__restrictedHolders:
# Container for skill requirement errors
skillRequirementErrors = []
# Check each skill requirement
for requiredSkillId in holder.item.requiredSkills:
requiredSkillLevel = holder.item.requiredSkills[
requiredSkillId]
skillHolders = self.__skillHolders.get(requiredSkillId) or ()
# Pick max level of all skill holders, absence of skill
# is considered as skill level set to None
skillLevel = None
for skillHolder in skillHolders:
skillHolderLevel = skillHolder.level
if skillLevel is None:
skillLevel = skillHolderLevel
elif skillHolderLevel is not None:
skillLevel = max(skillLevel, skillHolderLevel)
# Last check - if skill level is lower than expected, current holder
# is tainted; mark it so and move to the next one
if skillLevel is None or skillLevel < requiredSkillLevel:
skillRequirementError = SkillRequirementErrorData(
skill=requiredSkillId,
level=skillLevel,
requiredLevel=requiredSkillLevel)
skillRequirementErrors.append(skillRequirementError)
if skillRequirementErrors:
taintedHolders[holder] = tuple(skillRequirementErrors)
if taintedHolders:
raise RegisterValidationError(taintedHolders)
@property
def restrictionType(self):
return Restriction.skillRequirement
