dave/pyfa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 21 Wiki Activity

Rename inputs into params when they are actually not inputs

Browse Source
This commit is contained in:
DarkPhoenix
2019-08-01 20:15:49 +03:00
parent 18d59c119c
commit 0788ff050d
6 changed files with 123 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
gui/builtinGraphs/base.py
View File

@@ -230,13 +230,13 @@ class FitGraph(metaclass=ABCMeta):
_getters = {} _getters = {}
def _getPoints(self, mainInput, miscInputs, xSpec, ySpec, fit, tgt): def _getPoints(self, mainParam, miscParams, xSpec, ySpec, fit, tgt):
try: try:
getter = self._getters[(xSpec.handle, ySpec.handle)] getter = self._getters[(xSpec.handle, ySpec.handle)]
except KeyError: except KeyError:
return [], [] return [], []
else: else:
return getter(self, mainInput, miscInputs, fit, tgt) return getter(self, mainParam, miscParams, fit, tgt)
_denormalizers = {} _denormalizers = {}

24
gui/builtinGraphs/fitCapRegen.py
View File

@@ -48,54 +48,54 @@ class FitCapRegenGraph(FitGraph):
_denormalizers = { _denormalizers = {
('capAmount', '%'): lambda v, fit, tgt: v * 100 / fit.ship.getModifiedItemAttr('capacitorCapacity')} ('capAmount', '%'): lambda v, fit, tgt: v * 100 / fit.ship.getModifiedItemAttr('capacitorCapacity')}
def _time2capAmount(self, mainInput, miscInputs, fit, tgt): def _time2capAmountFull(self, mainParam, miscParams, fit, tgt):
xs = [] xs = []
ys = [] ys = []
maxCapAmount = fit.ship.getModifiedItemAttr('capacitorCapacity') maxCapAmount = fit.ship.getModifiedItemAttr('capacitorCapacity')
capRegenTime = fit.ship.getModifiedItemAttr('rechargeRate') / 1000 capRegenTime = fit.ship.getModifiedItemAttr('rechargeRate') / 1000
for time in self._iterLinear(mainInput[1]): for time in self._iterLinear(mainParam[1]):
currentCapAmount = calculateCapAmount(maxCapAmount=maxCapAmount, capRegenTime=capRegenTime, time=time) currentCapAmount = calculateCapAmount(maxCapAmount=maxCapAmount, capRegenTime=capRegenTime, time=time)
xs.append(time) xs.append(time)
ys.append(currentCapAmount) ys.append(currentCapAmount)
return xs, ys return xs, ys
def _time2capRegen(self, mainInput, miscInputs, fit, tgt): def _time2capRegenFull(self, mainParam, miscParams, fit, tgt):
xs = [] xs = []
ys = [] ys = []
maxCapAmount = fit.ship.getModifiedItemAttr('capacitorCapacity') maxCapAmount = fit.ship.getModifiedItemAttr('capacitorCapacity')
capRegenTime = fit.ship.getModifiedItemAttr('rechargeRate') / 1000 capRegenTime = fit.ship.getModifiedItemAttr('rechargeRate') / 1000
for time in self._iterLinear(mainInput[1]): for time in self._iterLinear(mainParam[1]):
currentCapAmount = calculateCapAmount(maxCapAmount=maxCapAmount, capRegenTime=capRegenTime, time=time) currentCapAmount = calculateCapAmount(maxCapAmount=maxCapAmount, capRegenTime=capRegenTime, time=time)
currentCapRegen = calculateCapRegen(maxCapAmount=maxCapAmount, capRegenTime=capRegenTime, currentCapAmount=currentCapAmount) currentCapRegen = calculateCapRegen(maxCapAmount=maxCapAmount, capRegenTime=capRegenTime, currentCapAmount=currentCapAmount)
xs.append(time) xs.append(time)
ys.append(currentCapRegen) ys.append(currentCapRegen)
return xs, ys return xs, ys
def _capAmount2capAmount(self, mainInput, miscInputs, fit, tgt): def _capAmount2capAmountFull(self, mainParam, miscParams, fit, tgt):
# Useless, but valid combination of x and y # Useless, but valid combination of x and y
xs = [] xs = []
ys = [] ys = []
for currentCapAmount in self._iterLinear(mainInput[1]): for currentCapAmount in self._iterLinear(mainParam[1]):
xs.append(currentCapAmount) xs.append(currentCapAmount)
ys.append(currentCapAmount) ys.append(currentCapAmount)
return xs, ys return xs, ys
def _capAmount2capRegen(self, mainInput, miscInputs, fit, tgt): def _capAmount2capRegenFull(self, mainParam, miscParams, fit, tgt):
xs = [] xs = []
ys = [] ys = []
maxCapAmount = fit.ship.getModifiedItemAttr('capacitorCapacity') maxCapAmount = fit.ship.getModifiedItemAttr('capacitorCapacity')
capRegenTime = fit.ship.getModifiedItemAttr('rechargeRate') / 1000 capRegenTime = fit.ship.getModifiedItemAttr('rechargeRate') / 1000
for currentCapAmount in self._iterLinear(mainInput[1]): for currentCapAmount in self._iterLinear(mainParam[1]):
currentCapRegen = calculateCapRegen(maxCapAmount=maxCapAmount, capRegenTime=capRegenTime, currentCapAmount=currentCapAmount) currentCapRegen = calculateCapRegen(maxCapAmount=maxCapAmount, capRegenTime=capRegenTime, currentCapAmount=currentCapAmount)
xs.append(currentCapAmount) xs.append(currentCapAmount)
ys.append(currentCapRegen) ys.append(currentCapRegen)
return xs, ys return xs, ys
_getters = { _getters = {
('time', 'capAmount'): _time2capAmount, ('time', 'capAmount'): _time2capAmountFull,
('time', 'capRegen'): _time2capRegen, ('time', 'capRegen'): _time2capRegenFull,
('capAmount', 'capAmount'): _capAmount2capAmount, ('capAmount', 'capAmount'): _capAmount2capAmountFull,
('capAmount', 'capRegen'): _capAmount2capRegen} ('capAmount', 'capRegen'): _capAmount2capRegenFull}
def calculateCapAmount(maxCapAmount, capRegenTime, time): def calculateCapAmount(maxCapAmount, capRegenTime, time):

164
gui/builtinGraphs/fitDamageStats/graph.py
View File

@@ -92,93 +92,93 @@ class FitDamageStatsGraph(FitGraph):
('tgtSpeed', '%'): lambda v, fit, tgt: v * 100 / getTgtMaxVelocity(tgt), ('tgtSpeed', '%'): lambda v, fit, tgt: v * 100 / getTgtMaxVelocity(tgt),
('tgtSigRad', '%'): lambda v, fit, tgt: v * 100 / getTgtSigRadius(tgt)} ('tgtSigRad', '%'): lambda v, fit, tgt: v * 100 / getTgtSigRadius(tgt)}
def _distance2dps(self, mainInput, miscInputs, fit, tgt): def _distance2dpsFull(self, mainParam, miscParams, fit, tgt):
return self._xDistanceGetter( return self._xDistanceGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
dmgFunc=self._getDpsPerKey, timeCachePrepFunc=self._timeCache.prepareDpsData) dmgFunc=self._getDpsPerKey, timeCachePrepFunc=self._timeCache.prepareDpsData)
def _distance2volley(self, mainInput, miscInputs, fit, tgt): def _distance2volleyFull(self, mainParam, miscParams, fit, tgt):
return self._xDistanceGetter( return self._xDistanceGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
dmgFunc=self._getVolleyPerKey, timeCachePrepFunc=self._timeCache.prepareVolleyData) dmgFunc=self._getVolleyPerKey, timeCachePrepFunc=self._timeCache.prepareVolleyData)
def _distance2damage(self, mainInput, miscInputs, fit, tgt): def _distance2damageFull(self, mainParam, miscParams, fit, tgt):
return self._xDistanceGetter( return self._xDistanceGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
dmgFunc=self._getDmgPerKey, timeCachePrepFunc=self._timeCache.prepareDmgData) dmgFunc=self._getDmgPerKey, timeCachePrepFunc=self._timeCache.prepareDmgData)
def _time2dps(self, mainInput, miscInputs, fit, tgt): def _time2dpsFull(self, mainParam, miscParams, fit, tgt):
return self._xTimeGetter( return self._xTimeGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
timeCachePrepFunc=self._timeCache.prepareDpsData, timeCacheGetFunc=self._timeCache.getDpsData) timeCachePrepFunc=self._timeCache.prepareDpsData, timeCacheGetFunc=self._timeCache.getDpsData)
def _time2volley(self, mainInput, miscInputs, fit, tgt): def _time2volleyFull(self, mainParam, miscParams, fit, tgt):
return self._xTimeGetter( return self._xTimeGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
timeCachePrepFunc=self._timeCache.prepareVolleyData, timeCacheGetFunc=self._timeCache.getVolleyData) timeCachePrepFunc=self._timeCache.prepareVolleyData, timeCacheGetFunc=self._timeCache.getVolleyData)
def _time2damage(self, mainInput, miscInputs, fit, tgt): def _time2damageFull(self, mainParam, miscParams, fit, tgt):
return self._xTimeGetter( return self._xTimeGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
timeCachePrepFunc=self._timeCache.prepareDmgData, timeCacheGetFunc=self._timeCache.getDmgData) timeCachePrepFunc=self._timeCache.prepareDmgData, timeCacheGetFunc=self._timeCache.getDmgData)
def _tgtSpeed2dps(self, mainInput, miscInputs, fit, tgt): def _tgtSpeed2dpsFull(self, mainParam, miscParams, fit, tgt):
return self._xTgtSpeedGetter( return self._xTgtSpeedGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
dmgFunc=self._getDpsPerKey, timeCachePrepFunc=self._timeCache.prepareDpsData) dmgFunc=self._getDpsPerKey, timeCachePrepFunc=self._timeCache.prepareDpsData)
def _tgtSpeed2volley(self, mainInput, miscInputs, fit, tgt): def _tgtSpeed2volleyFull(self, mainParam, miscParams, fit, tgt):
return self._xTgtSpeedGetter( return self._xTgtSpeedGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
dmgFunc=self._getVolleyPerKey, timeCachePrepFunc=self._timeCache.prepareVolleyData) dmgFunc=self._getVolleyPerKey, timeCachePrepFunc=self._timeCache.prepareVolleyData)
def _tgtSpeed2damage(self, mainInput, miscInputs, fit, tgt): def _tgtSpeed2damageFull(self, mainParam, miscParams, fit, tgt):
return self._xTgtSpeedGetter( return self._xTgtSpeedGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
dmgFunc=self._getDmgPerKey, timeCachePrepFunc=self._timeCache.prepareDmgData) dmgFunc=self._getDmgPerKey, timeCachePrepFunc=self._timeCache.prepareDmgData)
def _tgtSigRad2dps(self, mainInput, miscInputs, fit, tgt): def _tgtSigRad2dpsFull(self, mainParam, miscParams, fit, tgt):
return self._xTgtSigRadiusGetter( return self._xTgtSigRadiusGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
dmgFunc=self._getDpsPerKey, timeCachePrepFunc=self._timeCache.prepareDpsData) dmgFunc=self._getDpsPerKey, timeCachePrepFunc=self._timeCache.prepareDpsData)
def _tgtSigRad2volley(self, mainInput, miscInputs, fit, tgt): def _tgtSigRad2volleyFull(self, mainParam, miscParams, fit, tgt):
return self._xTgtSigRadiusGetter( return self._xTgtSigRadiusGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
dmgFunc=self._getVolleyPerKey, timeCachePrepFunc=self._timeCache.prepareVolleyData) dmgFunc=self._getVolleyPerKey, timeCachePrepFunc=self._timeCache.prepareVolleyData)
def _tgtSigRad2damage(self, mainInput, miscInputs, fit, tgt): def _tgtSigRad2damageFull(self, mainParam, miscParams, fit, tgt):
return self._xTgtSigRadiusGetter( return self._xTgtSigRadiusGetter(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt, mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
dmgFunc=self._getDmgPerKey, timeCachePrepFunc=self._timeCache.prepareDmgData) dmgFunc=self._getDmgPerKey, timeCachePrepFunc=self._timeCache.prepareDmgData)
_getters = { _getters = {
('distance', 'dps'): _distance2dps, ('distance', 'dps'): _distance2dpsFull,
('distance', 'volley'): _distance2volley, ('distance', 'volley'): _distance2volleyFull,
('distance', 'damage'): _distance2damage, ('distance', 'damage'): _distance2damageFull,
('time', 'dps'): _time2dps, ('time', 'dps'): _time2dpsFull,
('time', 'volley'): _time2volley, ('time', 'volley'): _time2volleyFull,
('time', 'damage'): _time2damage, ('time', 'damage'): _time2damageFull,
('tgtSpeed', 'dps'): _tgtSpeed2dps, ('tgtSpeed', 'dps'): _tgtSpeed2dpsFull,
('tgtSpeed', 'volley'): _tgtSpeed2volley, ('tgtSpeed', 'volley'): _tgtSpeed2volleyFull,
('tgtSpeed', 'damage'): _tgtSpeed2damage, ('tgtSpeed', 'damage'): _tgtSpeed2damageFull,
('tgtSigRad', 'dps'): _tgtSigRad2dps, ('tgtSigRad', 'dps'): _tgtSigRad2dpsFull,
('tgtSigRad', 'volley'): _tgtSigRad2volley, ('tgtSigRad', 'volley'): _tgtSigRad2volleyFull,
('tgtSigRad', 'damage'): _tgtSigRad2damage} ('tgtSigRad', 'damage'): _tgtSigRad2damageFull}
# Point getter helpers # Point getter helpers
def _xDistanceGetter(self, mainInput, miscInputs, fit, tgt, dmgFunc, timeCachePrepFunc): def _xDistanceGetter(self, mainParam, miscParams, fit, tgt, dmgFunc, timeCachePrepFunc):
xs = [] xs = []
ys = [] ys = []
applyProjected = GraphSettings.getInstance().get('applyProjected') applyProjected = GraphSettings.getInstance().get('applyProjected')
# Process inputs into more convenient form # Process params into more convenient form
miscInputMap = dict(miscInputs) miscParamMap = dict(miscParams)
# Get all data we need for all distances into maps/caches # Get all data we need for all distances into maps/caches
timeCachePrepFunc(fit, miscInputMap['time']) timeCachePrepFunc(fit, miscParamMap['time'])
dmgMap = dmgFunc(fit=fit, time=miscInputMap['time']) dmgMap = dmgFunc(fit=fit, time=miscParamMap['time'])
# Go through distances and calculate distance-dependent data # Go through distances and calculate distance-dependent data
for distance in self._iterLinear(mainInput[1]): for distance in self._iterLinear(mainParam[1]):
tgtSpeed = miscInputMap['tgtSpeed'] tgtSpeed = miscParamMap['tgtSpeed']
tgtSigRadius = getTgtSigRadius(tgt) tgtSigRadius = getTgtSigRadius(tgt)
if applyProjected: if applyProjected:
webMods, tpMods = self._projectedCache.getProjModData(fit) webMods, tpMods = self._projectedCache.getProjModData(fit)
@@ -203,24 +203,24 @@ class FitDamageStatsGraph(FitGraph):
applicationMap = self._getApplicationPerKey( applicationMap = self._getApplicationPerKey(
fit=fit, fit=fit,
tgt=tgt, tgt=tgt,
atkSpeed=miscInputMap['atkSpeed'], atkSpeed=miscParamMap['atkSpeed'],
atkAngle=miscInputMap['atkAngle'], atkAngle=miscParamMap['atkAngle'],
distance=distance, distance=distance,
tgtSpeed=tgtSpeed, tgtSpeed=tgtSpeed,
tgtAngle=miscInputMap['tgtAngle'], tgtAngle=miscParamMap['tgtAngle'],
tgtSigRadius=tgtSigRadius) tgtSigRadius=tgtSigRadius)
dmg = self._aggregate(dmgMap=dmgMap, applicationMap=applicationMap).total dmg = self._aggregate(dmgMap=dmgMap, applicationMap=applicationMap).total
xs.append(distance) xs.append(distance)
ys.append(dmg) ys.append(dmg)
return xs, ys return xs, ys
def _xTimeGetter(self, mainInput, miscInputs, fit, tgt, timeCachePrepFunc, timeCacheGetFunc): def _xTimeGetter(self, mainParam, miscParams, fit, tgt, timeCachePrepFunc, timeCacheGetFunc):
xs = [] xs = []
ys = [] ys = []
minTime, maxTime = mainInput[1] minTime, maxTime = mainParam[1]
# Process inputs into more convenient form # Process params into more convenient form
miscInputMap = dict(miscInputs) miscParamMap = dict(miscParams)
tgtSpeed = miscInputMap['tgtSpeed'] tgtSpeed = miscParamMap['tgtSpeed']
tgtSigRadius = getTgtSigRadius(tgt) tgtSigRadius = getTgtSigRadius(tgt)
if GraphSettings.getInstance().get('applyProjected'): if GraphSettings.getInstance().get('applyProjected'):
webMods, tpMods = self._projectedCache.getProjModData(fit) webMods, tpMods = self._projectedCache.getProjModData(fit)
@@ -233,7 +233,7 @@ class FitDamageStatsGraph(FitGraph):
webMods=webMods, webMods=webMods,
webDrones=webDrones, webDrones=webDrones,
webFighters=webFighters, webFighters=webFighters,
distance=miscInputMap['distance']) distance=miscParamMap['distance'])
tgtSigRadius = tgtSigRadius * getTpMult( tgtSigRadius = tgtSigRadius * getTpMult(
fit=fit, fit=fit,
tgt=tgt, tgt=tgt,
@@ -241,16 +241,16 @@ class FitDamageStatsGraph(FitGraph):
tpMods=tpMods, tpMods=tpMods,
tpDrones=tpDrones, tpDrones=tpDrones,
tpFighters=tpFighters, tpFighters=tpFighters,
distance=miscInputMap['distance']) distance=miscParamMap['distance'])
# Get all data we need for all times into maps/caches # Get all data we need for all times into maps/caches
applicationMap = self._getApplicationPerKey( applicationMap = self._getApplicationPerKey(
fit=fit, fit=fit,
tgt=tgt, tgt=tgt,
atkSpeed=miscInputMap['atkSpeed'], atkSpeed=miscParamMap['atkSpeed'],
atkAngle=miscInputMap['atkAngle'], atkAngle=miscParamMap['atkAngle'],
distance=miscInputMap['distance'], distance=miscParamMap['distance'],
tgtSpeed=tgtSpeed, tgtSpeed=tgtSpeed,
tgtAngle=miscInputMap['tgtAngle'], tgtAngle=miscParamMap['tgtAngle'],
tgtSigRadius=tgtSigRadius) tgtSigRadius=tgtSigRadius)
timeCachePrepFunc(fit, maxTime) timeCachePrepFunc(fit, maxTime)
timeCache = timeCacheGetFunc(fit) timeCache = timeCacheGetFunc(fit)
@@ -300,17 +300,17 @@ class FitDamageStatsGraph(FitGraph):
ys.append(currentDmg or 0) ys.append(currentDmg or 0)
return xs, ys return xs, ys
def _xTgtSpeedGetter(self, mainInput, miscInputs, fit, tgt, dmgFunc, timeCachePrepFunc): def _xTgtSpeedGetter(self, mainParam, miscParams, fit, tgt, dmgFunc, timeCachePrepFunc):
xs = [] xs = []
ys = [] ys = []
applyProjected = GraphSettings.getInstance().get('applyProjected') applyProjected = GraphSettings.getInstance().get('applyProjected')
# Process inputs into more convenient form # Process params into more convenient form
miscInputMap = dict(miscInputs) miscParamMap = dict(miscParams)
# Get all data we need for all target speeds into maps/caches # Get all data we need for all target speeds into maps/caches
timeCachePrepFunc(fit, miscInputMap['time']) timeCachePrepFunc(fit, miscParamMap['time'])
dmgMap = dmgFunc(fit=fit, time=miscInputMap['time']) dmgMap = dmgFunc(fit=fit, time=miscParamMap['time'])
# Go through target speeds and calculate distance-dependent data # Go through target speeds and calculate distance-dependent data
for tgtSpeed in self._iterLinear(mainInput[1]): for tgtSpeed in self._iterLinear(mainParam[1]):
# Get separate internal speed to calculate proper application, for graph # Get separate internal speed to calculate proper application, for graph
# itself we still want to show pre-modification speed on X axis # itself we still want to show pre-modification speed on X axis
tgtSpeedInternal = tgtSpeed tgtSpeedInternal = tgtSpeed
@@ -326,7 +326,7 @@ class FitDamageStatsGraph(FitGraph):
webMods=webMods, webMods=webMods,
webDrones=webDrones, webDrones=webDrones,
webFighters=webFighters, webFighters=webFighters,
distance=miscInputMap['distance']) distance=miscParamMap['distance'])
tgtSigRadius = tgtSigRadius * getTpMult( tgtSigRadius = tgtSigRadius * getTpMult(
fit=fit, fit=fit,
tgt=tgt, tgt=tgt,
@@ -334,27 +334,27 @@ class FitDamageStatsGraph(FitGraph):
tpMods=tpMods, tpMods=tpMods,
tpDrones=tpDrones, tpDrones=tpDrones,
tpFighters=tpFighters, tpFighters=tpFighters,
distance=miscInputMap['distance']) distance=miscParamMap['distance'])
applicationMap = self._getApplicationPerKey( applicationMap = self._getApplicationPerKey(
fit=fit, fit=fit,
tgt=tgt, tgt=tgt,
atkSpeed=miscInputMap['atkSpeed'], atkSpeed=miscParamMap['atkSpeed'],
atkAngle=miscInputMap['atkAngle'], atkAngle=miscParamMap['atkAngle'],
distance=miscInputMap['distance'], distance=miscParamMap['distance'],
tgtSpeed=tgtSpeedInternal, tgtSpeed=tgtSpeedInternal,
tgtAngle=miscInputMap['tgtAngle'], tgtAngle=miscParamMap['tgtAngle'],
tgtSigRadius=tgtSigRadius) tgtSigRadius=tgtSigRadius)
dmg = self._aggregate(dmgMap=dmgMap, applicationMap=applicationMap).total dmg = self._aggregate(dmgMap=dmgMap, applicationMap=applicationMap).total
xs.append(tgtSpeed) xs.append(tgtSpeed)
ys.append(dmg) ys.append(dmg)
return xs, ys return xs, ys
def _xTgtSigRadiusGetter(self, mainInput, miscInputs, fit, tgt, dmgFunc, timeCachePrepFunc): def _xTgtSigRadiusGetter(self, mainParam, miscParams, fit, tgt, dmgFunc, timeCachePrepFunc):
xs = [] xs = []
ys = [] ys = []
# Process inputs into more convenient form # Process params into more convenient form
miscInputMap = dict(miscInputs) miscParamMap = dict(miscParams)
tgtSpeed = miscInputMap['tgtSpeed'] tgtSpeed = miscParamMap['tgtSpeed']
tgtSigMult = 1 tgtSigMult = 1
if GraphSettings.getInstance().get('applyProjected'): if GraphSettings.getInstance().get('applyProjected'):
webMods, tpMods = self._projectedCache.getProjModData(fit) webMods, tpMods = self._projectedCache.getProjModData(fit)
@@ -367,7 +367,7 @@ class FitDamageStatsGraph(FitGraph):
webMods=webMods, webMods=webMods,
webDrones=webDrones, webDrones=webDrones,
webFighters=webFighters, webFighters=webFighters,
distance=miscInputMap['distance']) distance=miscParamMap['distance'])
tgtSigMult = getTpMult( tgtSigMult = getTpMult(
fit=fit, fit=fit,
tgt=tgt, tgt=tgt,
@@ -375,23 +375,23 @@ class FitDamageStatsGraph(FitGraph):
tpMods=tpMods, tpMods=tpMods,
tpDrones=tpDrones, tpDrones=tpDrones,
tpFighters=tpFighters, tpFighters=tpFighters,
distance=miscInputMap['distance']) distance=miscParamMap['distance'])
# Get all data we need for all target speeds into maps/caches # Get all data we need for all target speeds into maps/caches
timeCachePrepFunc(fit, miscInputMap['time']) timeCachePrepFunc(fit, miscParamMap['time'])
dmgMap = dmgFunc(fit=fit, time=miscInputMap['time']) dmgMap = dmgFunc(fit=fit, time=miscParamMap['time'])
# Go through target speeds and calculate distance-dependent data # Go through target speeds and calculate distance-dependent data
for tgtSigRadius in self._iterLinear(mainInput[1]): for tgtSigRadius in self._iterLinear(mainParam[1]):
# Separate variable to show base signature on X axis and use modified # Separate variable to show base signature on X axis and use modified
# signature in calculations # signature in calculations
tgtSigRadiusInternal = tgtSigRadius * tgtSigMult tgtSigRadiusInternal = tgtSigRadius * tgtSigMult
applicationMap = self._getApplicationPerKey( applicationMap = self._getApplicationPerKey(
fit=fit, fit=fit,
tgt=tgt, tgt=tgt,
atkSpeed=miscInputMap['atkSpeed'], atkSpeed=miscParamMap['atkSpeed'],
atkAngle=miscInputMap['atkAngle'], atkAngle=miscParamMap['atkAngle'],
distance=miscInputMap['distance'], distance=miscParamMap['distance'],
tgtSpeed=tgtSpeed, tgtSpeed=tgtSpeed,
tgtAngle=miscInputMap['tgtAngle'], tgtAngle=miscParamMap['tgtAngle'],
tgtSigRadius=tgtSigRadiusInternal) tgtSigRadius=tgtSigRadiusInternal)
dmg = self._aggregate(dmgMap=dmgMap, applicationMap=applicationMap).total dmg = self._aggregate(dmgMap=dmgMap, applicationMap=applicationMap).total
xs.append(tgtSigRadius) xs.append(tgtSigRadius)

12
gui/builtinGraphs/fitMobility.py
View File

@@ -41,26 +41,26 @@ class FitMobilityVsTimeGraph(FitGraph):
_denormalizers = { _denormalizers = {
('distance', 'km'): lambda v, fit, tgt: v / 1000} ('distance', 'km'): lambda v, fit, tgt: v / 1000}
def _time2speed(self, mainInput, miscInputs, fit, tgt): def _time2speedFull(self, mainParam, miscParams, fit, tgt):
xs = [] xs = []
ys = [] ys = []
maxSpeed = fit.ship.getModifiedItemAttr('maxVelocity') maxSpeed = fit.ship.getModifiedItemAttr('maxVelocity')
mass = fit.ship.getModifiedItemAttr('mass') mass = fit.ship.getModifiedItemAttr('mass')
agility = fit.ship.getModifiedItemAttr('agility') agility = fit.ship.getModifiedItemAttr('agility')
for time in self._iterLinear(mainInput[1]): for time in self._iterLinear(mainParam[1]):
# https://wiki.eveuniversity.org/Acceleration#Mathematics_and_formulae # https://wiki.eveuniversity.org/Acceleration#Mathematics_and_formulae
speed = maxSpeed * (1 - math.exp((-time * 1000000) / (agility * mass))) speed = maxSpeed * (1 - math.exp((-time * 1000000) / (agility * mass)))
xs.append(time) xs.append(time)
ys.append(speed) ys.append(speed)
return xs, ys return xs, ys
def _time2distance(self, mainInput, miscInputs, fit, tgt): def _time2distanceFull(self, mainParam, miscParams, fit, tgt):
xs = [] xs = []
ys = [] ys = []
maxSpeed = fit.ship.getModifiedItemAttr('maxVelocity') maxSpeed = fit.ship.getModifiedItemAttr('maxVelocity')
mass = fit.ship.getModifiedItemAttr('mass') mass = fit.ship.getModifiedItemAttr('mass')
agility = fit.ship.getModifiedItemAttr('agility') agility = fit.ship.getModifiedItemAttr('agility')
for time in self._iterLinear(mainInput[1]): for time in self._iterLinear(mainParam[1]):
# Definite integral of: # Definite integral of:
# https://wiki.eveuniversity.org/Acceleration#Mathematics_and_formulae # https://wiki.eveuniversity.org/Acceleration#Mathematics_and_formulae
distance_t = maxSpeed * time + (maxSpeed * agility * mass * math.exp((-time * 1000000) / (agility * mass)) / 1000000) distance_t = maxSpeed * time + (maxSpeed * agility * mass * math.exp((-time * 1000000) / (agility * mass)) / 1000000)
@@ -71,8 +71,8 @@ class FitMobilityVsTimeGraph(FitGraph):
return xs, ys return xs, ys
_getters = { _getters = {
('time', 'speed'): _time2speed, ('time', 'speed'): _time2speedFull,
('time', 'distance'): _time2distance} ('time', 'distance'): _time2distanceFull}
FitMobilityVsTimeGraph.register() FitMobilityVsTimeGraph.register()

24
gui/builtinGraphs/fitShieldRegen.py
View File

@@ -53,54 +53,54 @@ class FitShieldRegenGraph(FitGraph):
('shieldAmount', 'EHP'): lambda v, fit, tgt: fit.damagePattern.effectivify(fit, v, 'shield'), ('shieldAmount', 'EHP'): lambda v, fit, tgt: fit.damagePattern.effectivify(fit, v, 'shield'),
('shieldRegen', 'EHP/s'): lambda v, fit, tgt: fit.damagePattern.effectivify(fit, v, 'shield')} ('shieldRegen', 'EHP/s'): lambda v, fit, tgt: fit.damagePattern.effectivify(fit, v, 'shield')}
def _time2shieldAmount(self, mainInput, miscInputs, fit, tgt): def _time2shieldAmountFull(self, mainParam, miscParams, fit, tgt):
xs = [] xs = []
ys = [] ys = []
maxShieldAmount = fit.ship.getModifiedItemAttr('shieldCapacity') maxShieldAmount = fit.ship.getModifiedItemAttr('shieldCapacity')
shieldRegenTime = fit.ship.getModifiedItemAttr('shieldRechargeRate') / 1000 shieldRegenTime = fit.ship.getModifiedItemAttr('shieldRechargeRate') / 1000
for time in self._iterLinear(mainInput[1]): for time in self._iterLinear(mainParam[1]):
currentShieldAmount = calculateShieldAmount(maxShieldAmount=maxShieldAmount, shieldRegenTime=shieldRegenTime, time=time) currentShieldAmount = calculateShieldAmount(maxShieldAmount=maxShieldAmount, shieldRegenTime=shieldRegenTime, time=time)
xs.append(time) xs.append(time)
ys.append(currentShieldAmount) ys.append(currentShieldAmount)
return xs, ys return xs, ys
def _time2shieldRegen(self, mainInput, miscInputs, fit, tgt): def _time2shieldRegenFull(self, mainParam, miscParams, fit, tgt):
xs = [] xs = []
ys = [] ys = []
maxShieldAmount = fit.ship.getModifiedItemAttr('shieldCapacity') maxShieldAmount = fit.ship.getModifiedItemAttr('shieldCapacity')
shieldRegenTime = fit.ship.getModifiedItemAttr('shieldRechargeRate') / 1000 shieldRegenTime = fit.ship.getModifiedItemAttr('shieldRechargeRate') / 1000
for time in self._iterLinear(mainInput[1]): for time in self._iterLinear(mainParam[1]):
currentShieldAmount = calculateShieldAmount(maxShieldAmount=maxShieldAmount, shieldRegenTime=shieldRegenTime, time=time) currentShieldAmount = calculateShieldAmount(maxShieldAmount=maxShieldAmount, shieldRegenTime=shieldRegenTime, time=time)
currentShieldRegen = calculateShieldRegen(maxShieldAmount=maxShieldAmount, shieldRegenTime=shieldRegenTime, currentShieldAmount=currentShieldAmount) currentShieldRegen = calculateShieldRegen(maxShieldAmount=maxShieldAmount, shieldRegenTime=shieldRegenTime, currentShieldAmount=currentShieldAmount)
xs.append(time) xs.append(time)
ys.append(currentShieldRegen) ys.append(currentShieldRegen)
return xs, ys return xs, ys
def _shieldAmount2shieldAmount(self, mainInput, miscInputs, fit, tgt): def _shieldAmount2shieldAmountFull(self, mainParam, miscParams, fit, tgt):
# Useless, but valid combination of x and y # Useless, but valid combination of x and y
xs = [] xs = []
ys = [] ys = []
for currentShieldAmount in self._iterLinear(mainInput[1]): for currentShieldAmount in self._iterLinear(mainParam[1]):
xs.append(currentShieldAmount) xs.append(currentShieldAmount)
ys.append(currentShieldAmount) ys.append(currentShieldAmount)
return xs, ys return xs, ys
def _shieldAmount2shieldRegen(self, mainInput, miscInputs, fit, tgt): def _shieldAmount2shieldRegenFull(self, mainParam, miscParams, fit, tgt):
xs = [] xs = []
ys = [] ys = []
maxShieldAmount = fit.ship.getModifiedItemAttr('shieldCapacity') maxShieldAmount = fit.ship.getModifiedItemAttr('shieldCapacity')
shieldRegenTime = fit.ship.getModifiedItemAttr('shieldRechargeRate') / 1000 shieldRegenTime = fit.ship.getModifiedItemAttr('shieldRechargeRate') / 1000
for currentShieldAmount in self._iterLinear(mainInput[1]): for currentShieldAmount in self._iterLinear(mainParam[1]):
currentShieldRegen = calculateShieldRegen(maxShieldAmount=maxShieldAmount, shieldRegenTime=shieldRegenTime, currentShieldAmount=currentShieldAmount) currentShieldRegen = calculateShieldRegen(maxShieldAmount=maxShieldAmount, shieldRegenTime=shieldRegenTime, currentShieldAmount=currentShieldAmount)
xs.append(currentShieldAmount) xs.append(currentShieldAmount)
ys.append(currentShieldRegen) ys.append(currentShieldRegen)
return xs, ys return xs, ys
_getters = { _getters = {
('time', 'shieldAmount'): _time2shieldAmount, ('time', 'shieldAmount'): _time2shieldAmountFull,
('time', 'shieldRegen'): _time2shieldRegen, ('time', 'shieldRegen'): _time2shieldRegenFull,
('shieldAmount', 'shieldAmount'): _shieldAmount2shieldAmount, ('shieldAmount', 'shieldAmount'): _shieldAmount2shieldAmountFull,
('shieldAmount', 'shieldRegen'): _shieldAmount2shieldRegen} ('shieldAmount', 'shieldRegen'): _shieldAmount2shieldRegenFull}
def calculateShieldAmount(maxShieldAmount, shieldRegenTime, time): def calculateShieldAmount(maxShieldAmount, shieldRegenTime, time):

12
gui/builtinGraphs/fitWarpTime.py
View File

@@ -63,19 +63,25 @@ class FitWarpTimeGraph(FitGraph):
('distance', 'AU'): lambda v, fit, tgt: v / AU_METERS, ('distance', 'AU'): lambda v, fit, tgt: v / AU_METERS,
('distance', 'km'): lambda v, fit, tgt: v / 1000} ('distance', 'km'): lambda v, fit, tgt: v / 1000}
def _distance2time(self, mainInput, miscInputs, fit, tgt): def _distance2timeFull(self, mainParam, miscParams, fit, tgt):
xs = [] xs = []
ys = [] ys = []
subwarpSpeed = self._subspeedCache.getSubwarpSpeed(fit) subwarpSpeed = self._subspeedCache.getSubwarpSpeed(fit)
warpSpeed = fit.warpSpeed warpSpeed = fit.warpSpeed
for distance in self._iterLinear(mainInput[1]): for distance in self._iterLinear(mainParam[1]):
time = calculate_time_in_warp(max_subwarp_speed=subwarpSpeed, max_warp_speed=warpSpeed, warp_dist=distance) time = calculate_time_in_warp(max_subwarp_speed=subwarpSpeed, max_warp_speed=warpSpeed, warp_dist=distance)
xs.append(distance) xs.append(distance)
ys.append(time) ys.append(time)
return xs, ys return xs, ys
def _distance2timeSingle(self, mainParam, miscParams, fit, tgt):
subwarpSpeed = self._subspeedCache.getSubwarpSpeed(fit)
warpSpeed = fit.warpSpeed
time = calculate_time_in_warp(max_subwarp_speed=subwarpSpeed, max_warp_speed=warpSpeed, warp_dist=mainParam)
return time
_getters = { _getters = {
('distance', 'time'): _distance2time} ('distance', 'time'): _distance2timeFull}
class SubwarpSpeedCache(FitDataCache): class SubwarpSpeedCache(FitDataCache):