dave/pyfa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 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 = {}
def _getPoints(self, mainInput, miscInputs, xSpec, ySpec, fit, tgt):
def _getPoints(self, mainParam, miscParams, xSpec, ySpec, fit, tgt):
try:
getter = self._getters[(xSpec.handle, ySpec.handle)]
except KeyError:
return [], []
else:
return getter(self, mainInput, miscInputs, fit, tgt)
return getter(self, mainParam, miscParams, fit, tgt)
_denormalizers = {}

24
gui/builtinGraphs/fitCapRegen.py
View File

@@ -48,54 +48,54 @@ class FitCapRegenGraph(FitGraph):
_denormalizers = {
('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 = []
ys = []
maxCapAmount = fit.ship.getModifiedItemAttr('capacitorCapacity')
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)
xs.append(time)
ys.append(currentCapAmount)
return xs, ys
def _time2capRegen(self, mainInput, miscInputs, fit, tgt):
def _time2capRegenFull(self, mainParam, miscParams, fit, tgt):
xs = []
ys = []
maxCapAmount = fit.ship.getModifiedItemAttr('capacitorCapacity')
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)
currentCapRegen = calculateCapRegen(maxCapAmount=maxCapAmount, capRegenTime=capRegenTime, currentCapAmount=currentCapAmount)
xs.append(time)
ys.append(currentCapRegen)
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
xs = []
ys = []
for currentCapAmount in self._iterLinear(mainInput[1]):
for currentCapAmount in self._iterLinear(mainParam[1]):
xs.append(currentCapAmount)
ys.append(currentCapAmount)
return xs, ys
def _capAmount2capRegen(self, mainInput, miscInputs, fit, tgt):
def _capAmount2capRegenFull(self, mainParam, miscParams, fit, tgt):
xs = []
ys = []
maxCapAmount = fit.ship.getModifiedItemAttr('capacitorCapacity')
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)
xs.append(currentCapAmount)
ys.append(currentCapRegen)
return xs, ys
_getters = {
('time', 'capAmount'): _time2capAmount,
('time', 'capRegen'): _time2capRegen,
('capAmount', 'capAmount'): _capAmount2capAmount,
('capAmount', 'capRegen'): _capAmount2capRegen}
('time', 'capAmount'): _time2capAmountFull,
('time', 'capRegen'): _time2capRegenFull,
('capAmount', 'capAmount'): _capAmount2capAmountFull,
('capAmount', 'capRegen'): _capAmount2capRegenFull}
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),
('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(
mainInput=mainInput, miscInputs=miscInputs, fit=fit, tgt=tgt,
mainParam=mainParam, miscParams=miscParams, fit=fit, tgt=tgt,
dmgFunc=self._getDpsPerKey, timeCachePrepFunc=self._timeCache.prepareDpsData)
def _distance2volley(self, mainInput, miscInputs, fit, tgt):
def _distance2volleyFull(self, mainParam, miscParams, fit, tgt):
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)
def _distance2damage(self, mainInput, miscInputs, fit, tgt):
def _distance2damageFull(self, mainParam, miscParams, fit, tgt):
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)
def _time2dps(self, mainInput, miscInputs, fit, tgt):
def _time2dpsFull(self, mainParam, miscParams, fit, tgt):
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)
def _time2volley(self, mainInput, miscInputs, fit, tgt):
def _time2volleyFull(self, mainParam, miscParams, fit, tgt):
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)
def _time2damage(self, mainInput, miscInputs, fit, tgt):
def _time2damageFull(self, mainParam, miscParams, fit, tgt):
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)
def _tgtSpeed2dps(self, mainInput, miscInputs, fit, tgt):
def _tgtSpeed2dpsFull(self, mainParam, miscParams, fit, tgt):
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)
def _tgtSpeed2volley(self, mainInput, miscInputs, fit, tgt):
def _tgtSpeed2volleyFull(self, mainParam, miscParams, fit, tgt):
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)
def _tgtSpeed2damage(self, mainInput, miscInputs, fit, tgt):
def _tgtSpeed2damageFull(self, mainParam, miscParams, fit, tgt):
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)
def _tgtSigRad2dps(self, mainInput, miscInputs, fit, tgt):
def _tgtSigRad2dpsFull(self, mainParam, miscParams, fit, tgt):
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)
def _tgtSigRad2volley(self, mainInput, miscInputs, fit, tgt):
def _tgtSigRad2volleyFull(self, mainParam, miscParams, fit, tgt):
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)
def _tgtSigRad2damage(self, mainInput, miscInputs, fit, tgt):
def _tgtSigRad2damageFull(self, mainParam, miscParams, fit, tgt):
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)
_getters = {
('distance', 'dps'): _distance2dps,
('distance', 'volley'): _distance2volley,
('distance', 'damage'): _distance2damage,
('time', 'dps'): _time2dps,
('time', 'volley'): _time2volley,
('time', 'damage'): _time2damage,
('tgtSpeed', 'dps'): _tgtSpeed2dps,
('tgtSpeed', 'volley'): _tgtSpeed2volley,
('tgtSpeed', 'damage'): _tgtSpeed2damage,
('tgtSigRad', 'dps'): _tgtSigRad2dps,
('tgtSigRad', 'volley'): _tgtSigRad2volley,
('tgtSigRad', 'damage'): _tgtSigRad2damage}
('distance', 'dps'): _distance2dpsFull,
('distance', 'volley'): _distance2volleyFull,
('distance', 'damage'): _distance2damageFull,
('time', 'dps'): _time2dpsFull,
('time', 'volley'): _time2volleyFull,
('time', 'damage'): _time2damageFull,
('tgtSpeed', 'dps'): _tgtSpeed2dpsFull,
('tgtSpeed', 'volley'): _tgtSpeed2volleyFull,
('tgtSpeed', 'damage'): _tgtSpeed2damageFull,
('tgtSigRad', 'dps'): _tgtSigRad2dpsFull,
('tgtSigRad', 'volley'): _tgtSigRad2volleyFull,
('tgtSigRad', 'damage'): _tgtSigRad2damageFull}
# Point getter helpers
def _xDistanceGetter(self, mainInput, miscInputs, fit, tgt, dmgFunc, timeCachePrepFunc):
def _xDistanceGetter(self, mainParam, miscParams, fit, tgt, dmgFunc, timeCachePrepFunc):
xs = []
ys = []
applyProjected = GraphSettings.getInstance().get('applyProjected')
# Process inputs into more convenient form
miscInputMap = dict(miscInputs)
# Process params into more convenient form
miscParamMap = dict(miscParams)
# Get all data we need for all distances into maps/caches
timeCachePrepFunc(fit, miscInputMap['time'])
dmgMap = dmgFunc(fit=fit, time=miscInputMap['time'])
timeCachePrepFunc(fit, miscParamMap['time'])
dmgMap = dmgFunc(fit=fit, time=miscParamMap['time'])
# Go through distances and calculate distance-dependent data
for distance in self._iterLinear(mainInput[1]):
tgtSpeed = miscInputMap['tgtSpeed']
for distance in self._iterLinear(mainParam[1]):
tgtSpeed = miscParamMap['tgtSpeed']
tgtSigRadius = getTgtSigRadius(tgt)
if applyProjected:
webMods, tpMods = self._projectedCache.getProjModData(fit)
@@ -203,24 +203,24 @@ class FitDamageStatsGraph(FitGraph):
applicationMap = self._getApplicationPerKey(
fit=fit,
tgt=tgt,
atkSpeed=miscInputMap['atkSpeed'],
atkAngle=miscInputMap['atkAngle'],
atkSpeed=miscParamMap['atkSpeed'],
atkAngle=miscParamMap['atkAngle'],
distance=distance,
tgtSpeed=tgtSpeed,
tgtAngle=miscInputMap['tgtAngle'],
tgtAngle=miscParamMap['tgtAngle'],
tgtSigRadius=tgtSigRadius)
dmg = self._aggregate(dmgMap=dmgMap, applicationMap=applicationMap).total
xs.append(distance)
ys.append(dmg)
return xs, ys
def _xTimeGetter(self, mainInput, miscInputs, fit, tgt, timeCachePrepFunc, timeCacheGetFunc):
def _xTimeGetter(self, mainParam, miscParams, fit, tgt, timeCachePrepFunc, timeCacheGetFunc):
xs = []
ys = []
minTime, maxTime = mainInput[1]
# Process inputs into more convenient form
miscInputMap = dict(miscInputs)
tgtSpeed = miscInputMap['tgtSpeed']
minTime, maxTime = mainParam[1]
# Process params into more convenient form
miscParamMap = dict(miscParams)
tgtSpeed = miscParamMap['tgtSpeed']
tgtSigRadius = getTgtSigRadius(tgt)
if GraphSettings.getInstance().get('applyProjected'):
webMods, tpMods = self._projectedCache.getProjModData(fit)
@@ -233,7 +233,7 @@ class FitDamageStatsGraph(FitGraph):
webMods=webMods,
webDrones=webDrones,
webFighters=webFighters,
distance=miscInputMap['distance'])
distance=miscParamMap['distance'])
tgtSigRadius = tgtSigRadius * getTpMult(
fit=fit,
tgt=tgt,
@@ -241,16 +241,16 @@ class FitDamageStatsGraph(FitGraph):
tpMods=tpMods,
tpDrones=tpDrones,
tpFighters=tpFighters,
distance=miscInputMap['distance'])
distance=miscParamMap['distance'])
# Get all data we need for all times into maps/caches
applicationMap = self._getApplicationPerKey(
fit=fit,
tgt=tgt,
atkSpeed=miscInputMap['atkSpeed'],
atkAngle=miscInputMap['atkAngle'],
distance=miscInputMap['distance'],
atkSpeed=miscParamMap['atkSpeed'],
atkAngle=miscParamMap['atkAngle'],
distance=miscParamMap['distance'],
tgtSpeed=tgtSpeed,
tgtAngle=miscInputMap['tgtAngle'],
tgtAngle=miscParamMap['tgtAngle'],
tgtSigRadius=tgtSigRadius)
timeCachePrepFunc(fit, maxTime)
timeCache = timeCacheGetFunc(fit)
@@ -300,17 +300,17 @@ class FitDamageStatsGraph(FitGraph):
ys.append(currentDmg or 0)
return xs, ys
def _xTgtSpeedGetter(self, mainInput, miscInputs, fit, tgt, dmgFunc, timeCachePrepFunc):
def _xTgtSpeedGetter(self, mainParam, miscParams, fit, tgt, dmgFunc, timeCachePrepFunc):
xs = []
ys = []
applyProjected = GraphSettings.getInstance().get('applyProjected')
# Process inputs into more convenient form
miscInputMap = dict(miscInputs)
# Process params into more convenient form
miscParamMap = dict(miscParams)
# Get all data we need for all target speeds into maps/caches
timeCachePrepFunc(fit, miscInputMap['time'])
dmgMap = dmgFunc(fit=fit, time=miscInputMap['time'])
timeCachePrepFunc(fit, miscParamMap['time'])
dmgMap = dmgFunc(fit=fit, time=miscParamMap['time'])
# 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
# itself we still want to show pre-modification speed on X axis
tgtSpeedInternal = tgtSpeed
@@ -326,7 +326,7 @@ class FitDamageStatsGraph(FitGraph):
webMods=webMods,
webDrones=webDrones,
webFighters=webFighters,
distance=miscInputMap['distance'])
distance=miscParamMap['distance'])
tgtSigRadius = tgtSigRadius * getTpMult(
fit=fit,
tgt=tgt,
@@ -334,27 +334,27 @@ class FitDamageStatsGraph(FitGraph):
tpMods=tpMods,
tpDrones=tpDrones,
tpFighters=tpFighters,
distance=miscInputMap['distance'])
distance=miscParamMap['distance'])
applicationMap = self._getApplicationPerKey(
fit=fit,
tgt=tgt,
atkSpeed=miscInputMap['atkSpeed'],
atkAngle=miscInputMap['atkAngle'],
distance=miscInputMap['distance'],
atkSpeed=miscParamMap['atkSpeed'],
atkAngle=miscParamMap['atkAngle'],
distance=miscParamMap['distance'],
tgtSpeed=tgtSpeedInternal,
tgtAngle=miscInputMap['tgtAngle'],
tgtAngle=miscParamMap['tgtAngle'],
tgtSigRadius=tgtSigRadius)
dmg = self._aggregate(dmgMap=dmgMap, applicationMap=applicationMap).total
xs.append(tgtSpeed)
ys.append(dmg)
return xs, ys
def _xTgtSigRadiusGetter(self, mainInput, miscInputs, fit, tgt, dmgFunc, timeCachePrepFunc):
def _xTgtSigRadiusGetter(self, mainParam, miscParams, fit, tgt, dmgFunc, timeCachePrepFunc):
xs = []
ys = []
# Process inputs into more convenient form
miscInputMap = dict(miscInputs)
tgtSpeed = miscInputMap['tgtSpeed']
# Process params into more convenient form
miscParamMap = dict(miscParams)
tgtSpeed = miscParamMap['tgtSpeed']
tgtSigMult = 1
if GraphSettings.getInstance().get('applyProjected'):
webMods, tpMods = self._projectedCache.getProjModData(fit)
@@ -367,7 +367,7 @@ class FitDamageStatsGraph(FitGraph):
webMods=webMods,
webDrones=webDrones,
webFighters=webFighters,
distance=miscInputMap['distance'])
distance=miscParamMap['distance'])
tgtSigMult = getTpMult(
fit=fit,
tgt=tgt,
@@ -375,23 +375,23 @@ class FitDamageStatsGraph(FitGraph):
tpMods=tpMods,
tpDrones=tpDrones,
tpFighters=tpFighters,
distance=miscInputMap['distance'])
distance=miscParamMap['distance'])
# Get all data we need for all target speeds into maps/caches
timeCachePrepFunc(fit, miscInputMap['time'])
dmgMap = dmgFunc(fit=fit, time=miscInputMap['time'])
timeCachePrepFunc(fit, miscParamMap['time'])
dmgMap = dmgFunc(fit=fit, time=miscParamMap['time'])
# 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
# signature in calculations
tgtSigRadiusInternal = tgtSigRadius * tgtSigMult
applicationMap = self._getApplicationPerKey(
fit=fit,
tgt=tgt,
atkSpeed=miscInputMap['atkSpeed'],
atkAngle=miscInputMap['atkAngle'],
distance=miscInputMap['distance'],
atkSpeed=miscParamMap['atkSpeed'],
atkAngle=miscParamMap['atkAngle'],
distance=miscParamMap['distance'],
tgtSpeed=tgtSpeed,
tgtAngle=miscInputMap['tgtAngle'],
tgtAngle=miscParamMap['tgtAngle'],
tgtSigRadius=tgtSigRadiusInternal)
dmg = self._aggregate(dmgMap=dmgMap, applicationMap=applicationMap).total
xs.append(tgtSigRadius)

12
gui/builtinGraphs/fitMobility.py
View File

@@ -41,26 +41,26 @@ class FitMobilityVsTimeGraph(FitGraph):
_denormalizers = {
('distance', 'km'): lambda v, fit, tgt: v / 1000}
def _time2speed(self, mainInput, miscInputs, fit, tgt):
def _time2speedFull(self, mainParam, miscParams, fit, tgt):
xs = []
ys = []
maxSpeed = fit.ship.getModifiedItemAttr('maxVelocity')
mass = fit.ship.getModifiedItemAttr('mass')
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
speed = maxSpeed * (1 - math.exp((-time * 1000000) / (agility * mass)))
xs.append(time)
ys.append(speed)
return xs, ys
def _time2distance(self, mainInput, miscInputs, fit, tgt):
def _time2distanceFull(self, mainParam, miscParams, fit, tgt):
xs = []
ys = []
maxSpeed = fit.ship.getModifiedItemAttr('maxVelocity')
mass = fit.ship.getModifiedItemAttr('mass')
agility = fit.ship.getModifiedItemAttr('agility')
for time in self._iterLinear(mainInput[1]):
for time in self._iterLinear(mainParam[1]):
# Definite integral of:
# https://wiki.eveuniversity.org/Acceleration#Mathematics_and_formulae
distance_t = maxSpeed * time + (maxSpeed * agility * mass * math.exp((-time * 1000000) / (agility * mass)) / 1000000)
@@ -71,8 +71,8 @@ class FitMobilityVsTimeGraph(FitGraph):
return xs, ys
_getters = {
('time', 'speed'): _time2speed,
('time', 'distance'): _time2distance}
('time', 'speed'): _time2speedFull,
('time', 'distance'): _time2distanceFull}
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'),
('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 = []
ys = []
maxShieldAmount = fit.ship.getModifiedItemAttr('shieldCapacity')
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)
xs.append(time)
ys.append(currentShieldAmount)
return xs, ys
def _time2shieldRegen(self, mainInput, miscInputs, fit, tgt):
def _time2shieldRegenFull(self, mainParam, miscParams, fit, tgt):
xs = []
ys = []
maxShieldAmount = fit.ship.getModifiedItemAttr('shieldCapacity')
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)
currentShieldRegen = calculateShieldRegen(maxShieldAmount=maxShieldAmount, shieldRegenTime=shieldRegenTime, currentShieldAmount=currentShieldAmount)
xs.append(time)
ys.append(currentShieldRegen)
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
xs = []
ys = []
for currentShieldAmount in self._iterLinear(mainInput[1]):
for currentShieldAmount in self._iterLinear(mainParam[1]):
xs.append(currentShieldAmount)
ys.append(currentShieldAmount)
return xs, ys
def _shieldAmount2shieldRegen(self, mainInput, miscInputs, fit, tgt):
def _shieldAmount2shieldRegenFull(self, mainParam, miscParams, fit, tgt):
xs = []
ys = []
maxShieldAmount = fit.ship.getModifiedItemAttr('shieldCapacity')
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)
xs.append(currentShieldAmount)
ys.append(currentShieldRegen)
return xs, ys
_getters = {
('time', 'shieldAmount'): _time2shieldAmount,
('time', 'shieldRegen'): _time2shieldRegen,
('shieldAmount', 'shieldAmount'): _shieldAmount2shieldAmount,
('shieldAmount', 'shieldRegen'): _shieldAmount2shieldRegen}
('time', 'shieldAmount'): _time2shieldAmountFull,
('time', 'shieldRegen'): _time2shieldRegenFull,
('shieldAmount', 'shieldAmount'): _shieldAmount2shieldAmountFull,
('shieldAmount', 'shieldRegen'): _shieldAmount2shieldRegenFull}
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', 'km'): lambda v, fit, tgt: v / 1000}
def _distance2time(self, mainInput, miscInputs, fit, tgt):
def _distance2timeFull(self, mainParam, miscParams, fit, tgt):
xs = []
ys = []
subwarpSpeed = self._subspeedCache.getSubwarpSpeed(fit)
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)
xs.append(distance)
ys.append(time)
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 = {
('distance', 'time'): _distance2time}
('distance', 'time'): _distance2timeFull}
class SubwarpSpeedCache(FitDataCache):