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

Rework projected fighter fit commands

Browse Source
This commit is contained in:
DarkPhoenix
2019-04-13 18:26:05 +03:00
parent 7f870cf675
commit 1ca4c73a3e
12 changed files with 94 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
eos/effectHandlerHelpers.py
View File

@@ -405,6 +405,7 @@ class HandledProjectedDroneList(HandledDroneCargoList):
# Remove invalid or non-projectable drones
if proj.isInvalid or not proj.item.isType("projected"):
self.remove(proj)
proj.projected = False
raise HandledListActionError(proj)
return True
@@ -415,11 +416,11 @@ class HandledProjectedDroneList(HandledDroneCargoList):
# Remove invalid or non-projectable drones
if proj.isInvalid or not proj.item.isType("projected"):
self.remove(proj)
proj.projected = False
raise HandledListActionError(proj)
return True
class HandledItem(object):
def preAssignItemAttr(self, *args, **kwargs):
self.itemModifiedAttributes.preAssign(*args, **kwargs)

2
gui/fitCommands/calc/fitAddBooster.py
View File

@@ -69,5 +69,5 @@ class FitAddBoosterCommand(wx.Command):
position=self.oldPosition)
return cmd.Do()
from .fitRemoveBooster import FitRemoveBoosterCommand
cmd = FitRemoveBoosterCommand(self.fitID, self.newPosition)
cmd = FitRemoveBoosterCommand(fitID=self.fitID, position=self.newPosition)
return cmd.Do()

2
gui/fitCommands/calc/fitAddImplant.py
View File

@@ -68,5 +68,5 @@ class FitAddImplantCommand(wx.Command):
position=self.oldPosition)
return cmd.Do()
from .fitRemoveImplant import FitRemoveImplantCommand
cmd = FitRemoveImplantCommand(self.fitID, self.newPosition)
cmd = FitRemoveImplantCommand(fitID=self.fitID, position=self.newPosition)
return cmd.Do()

2
gui/fitCommands/calc/fitAddModule.py
View File

@@ -63,5 +63,5 @@ class FitAddModuleCommand(wx.Command):
from .fitRemoveModule import FitRemoveModuleCommand
if self.savedPosition is None:
return False
cmd = FitRemoveModuleCommand(self.fitID, [self.savedPosition])
cmd = FitRemoveModuleCommand(fitID=self.fitID, positions=[self.savedPosition])
return cmd.Do()

2
gui/fitCommands/calc/fitAddProjectedDrone.py
View File

@@ -62,5 +62,5 @@ class FitAddProjectedDroneCommand(wx.Command):
return True
# Removing new stack
from .fitRemoveProjectedDrone import FitRemoveProjectedDroneCommand
cmd = FitRemoveProjectedDroneCommand(self.fitID, self.droneInfo)
cmd = FitRemoveProjectedDroneCommand(fitID=self.fitID, droneInfo=self.droneInfo)
return cmd.Do()

63
gui/fitCommands/calc/fitAddProjectedFighter.py
View File

@@ -2,54 +2,45 @@ import wx
from logbook import Logger
import eos.db
from eos.saveddata.fighter import Fighter
from eos.exception import HandledListActionError
from service.fit import Fit
from service.market import Market
pyfalog = Logger(__name__)
class FitAddProjectedFighterCommand(wx.Command):
""""
from sFit.project
"""
def __init__(self, fitID, itemID, state, abilities):
wx.Command.__init__(self, True)
def __init__(self, fitID, fighterInfo, position=None):
wx.Command.__init__(self, True, 'Add Projected Fighter')
self.fitID = fitID
self.newItemID = itemID
self.newState = state
self.newAbilities = abilities
self.newIndex = None
self.fighterInfo = fighterInfo
self.position = position
def Do(self):
pyfalog.debug("Projecting fit ({0}) onto: {1}", self.fitID, self.newItemID)
pyfalog.debug('Doing addition of projected fighter {} onto: {}'.format(self.fighterInfo, self.fitID))
fighter = self.fighterInfo.toFighter()
if fighter is None:
return False
fit = Fit.getInstance().getFit(self.fitID)
item = Market.getInstance().getItem(self.newItemID, eager=("attributes", "group.category"))
try:
fighter = Fighter(item)
except ValueError:
return False
fit.projectedFighters.append(fighter)
# sometimes fighters aren't added because they aren't valid projectionable ones. todo: move that logic into here
if fighter not in fit.projectedFighters:
return False
if self.newState is not None:
fighter.active = self.newState
if self.newAbilities is not None:
for ability in fighter.abilities:
ability.active = self.newAbilities.get(ability.effectID, ability.active)
if self.position is not None:
try:
fit.projectedFighters.insert(self.position, fighter)
except HandledListActionError:
eos.db.commit()
return False
else:
try:
fit.projectedFighters.append(fighter)
except HandledListActionError:
eos.db.commit()
return False
self.position = fit.projectedFighters.index(fighter)
eos.db.commit()
self.newIndex = fit.projectedFighters.index(fighter)
return True
def Undo(self):
from gui.fitCommands.calc.fitRemoveProjectedFighter import FitRemoveProjectedFighterCommand # avoids circular import
cmd = FitRemoveProjectedFighterCommand(self.fitID, self.newIndex)
cmd.Do()
return True
pyfalog.debug('Undoing addition of projected fighter {} onto: {}'.format(self.fighterInfo, self.fitID))
from .fitRemoveProjectedFighter import FitRemoveProjectedFighterCommand
cmd = FitRemoveProjectedFighterCommand(fitID=self.fitID, position=self.position)
return cmd.Do()

12
gui/fitCommands/calc/fitAddProjectedModule.py
View File

@@ -12,21 +12,21 @@ pyfalog = Logger(__name__)
class FitAddProjectedModuleCommand(wx.Command):
def __init__(self, fitID, newModInfo, newPosition=None):
def __init__(self, fitID, modInfo, position=None):
wx.Command.__init__(self, True)
self.fitID = fitID
self.newModInfo = newModInfo
self.newPosition = newPosition
self.newModInfo = modInfo
self.newPosition = position
self.oldModInfo = None
self.oldPosition = None
def Do(self):
pyfalog.debug('Doing addition of projected module {} onto: {}'.format(self.newModInfo, self.fitID))
fit = Fit.getInstance().getFit(self.fitID)
newMod = self.newModInfo.toModule(fallbackState=FittingModuleState.ACTIVE)
if newMod is None:
return False
fit = Fit.getInstance().getFit(self.fitID)
if not newMod.canHaveState(newMod.state, projectedOnto=fit):
newMod.state = FittingModuleState.OFFLINE
@@ -54,8 +54,8 @@ class FitAddProjectedModuleCommand(wx.Command):
if self.oldPosition is not None and self.oldModInfo is not None:
cmd = FitAddProjectedModuleCommand(
fitID=self.fitID,
newModInfo=self.oldModInfo,
newPosition=self.oldPosition)
modInfo=self.oldModInfo,
position=self.oldPosition)
return cmd.Do()
if self.newPosition is None:
return False

2
gui/fitCommands/calc/fitRemoveProjectedDrone.py
View File

@@ -46,5 +46,5 @@ class FitRemoveProjectedDroneCommand(wx.Command):
return True
# Make new stack
from .fitAddProjectedDrone import FitAddProjectedDroneCommand
cmd = FitAddProjectedDroneCommand(self.fitID, self.savedDroneInfo)
cmd = FitAddProjectedDroneCommand(fitID=self.fitID, droneInfo=self.savedDroneInfo)
return cmd.Do()

39
gui/fitCommands/calc/fitRemoveProjectedFighter.py
View File

@@ -1,42 +1,33 @@
import wx
import eos.db
from logbook import Logger
import eos.db
from gui.fitCommands.helpers import FighterInfo
from service.fit import Fit
pyfalog = Logger(__name__)
# this has the same exact definition that regular rpojected modules, besides the undo
class FitRemoveProjectedFighterCommand(wx.Command):
""""
from sFit.project
"""
def __init__(self, fitID, position):
wx.Command.__init__(self, True)
wx.Command.__init__(self, True, 'Add Projected Fighter')
self.fitID = fitID
self.position = position
self.savedItemID = None
self.savedAmount = None
self.savedStatus = None
self.savedAbilities = None
self.savedFighterInfo = None
def Do(self):
pyfalog.debug("Removing ({0}) onto: {1}", self.fitID, self.position)
fit = eos.db.getFit(self.fitID)
pyfalog.debug('Doing removal of projected fighter at position {} from fit {}'.format(self.position, self.fitID))
fit = Fit.getInstance().getFit(self.fitID)
fighter = fit.projectedFighters[self.position]
self.savedItemID = fighter.itemID
self.savedAmount = fighter.amount
self.savedStatus = fighter.active
self.savedAbilities = {fa.effectID: fa.active for fa in fighter.abilities}
self.savedFighterInfo = FighterInfo.fromFighter(fighter)
fit.projectedFighters.remove(fighter)
eos.db.commit()
return True
def Undo(self):
from gui.fitCommands.calc.fitAddProjectedFighter import FitAddProjectedFighterCommand
cmd = FitAddProjectedFighterCommand(
fitID=self.fitID,
itemID=self.savedItemID,
state=self.savedStatus,
abilities=self.savedAbilities)
cmd.Do()
return True
pyfalog.debug('Undoing removal of projected fighter at position {} from fit {}'.format(self.position, self.fitID))
from .fitAddProjectedFighter import FitAddProjectedFighterCommand
cmd = FitAddProjectedFighterCommand(fitID=self.fitID, fighterInfo=self.savedFighterInfo)
return cmd.Do()

4
gui/fitCommands/calc/fitRemoveProjectedModule.py
View File

@@ -31,6 +31,6 @@ class FitRemoveProjectedModuleCommand(wx.Command):
from gui.fitCommands.calc.fitAddProjectedModule import FitAddProjectedModuleCommand
cmd = FitAddProjectedModuleCommand(
fitID=self.fitID,
newModInfo=self.savedModInfo,
newPosition=self.position)
modInfo=self.savedModInfo,
position=self.position)
return cmd.Do()

6
gui/fitCommands/guiAddProjected.py
View File

@@ -3,7 +3,7 @@ from service.fit import Fit
import gui.mainFrame
from gui import globalEvents as GE
from gui.fitCommands.helpers import ModuleInfo, DroneInfo
from gui.fitCommands.helpers import ModuleInfo, DroneInfo, FighterInfo
from .calc.fitAddProjectedModule import FitAddProjectedModuleCommand
from .calc.fitAddProjectedFit import FitAddProjectedFitCommand
from .calc.fitAddProjectedFighter import FitAddProjectedFighterCommand
@@ -35,11 +35,11 @@ class GuiAddProjectedCommand(wx.Command):
fitID=self.fitID,
droneInfo=DroneInfo(itemID=self.id, amount=1, amountActive=1)))
elif item.category.name == "Fighter":
result = self.internal_history.Submit(FitAddProjectedFighterCommand(self.fitID, self.id, None, None))
result = self.internal_history.Submit(FitAddProjectedFighterCommand(self.fitID, fighterInfo=FighterInfo(itemID=self.id)))
else:
result = self.internal_history.Submit(FitAddProjectedModuleCommand(
fitID=self.fitID,
newModInfo=ModuleInfo(itemID=self.id)))
modInfo=ModuleInfo(itemID=self.id)))
elif self.type == 'fit':
result = self.internal_history.Submit(FitAddProjectedFitCommand(self.fitID, self.id, None))

68
gui/fitCommands/helpers.py
View File

@@ -77,7 +77,7 @@ class ModuleInfo:
mod.state = fallbackState
if self.chargeID is not None:
charge = mkt.getItem(self.chargeID)
charge = mkt.getItem(self.chargeID, eager=('attributes',))
if charge is None:
pyfalog.warning('Cannot set charge {}'.format(self.chargeID))
return None
@@ -109,7 +109,7 @@ class DroneInfo:
return info
def toDrone(self):
item = Market.getInstance().getItem(self.itemID)
item = Market.getInstance().getItem(self.itemID, eager=('attributes', 'group.category'))
try:
drone = Drone(item)
except ValueError:
@@ -143,7 +143,7 @@ class FighterInfo:
return info
def toFighter(self):
item = Market.getInstance().getItem(self.itemID)
item = Market.getInstance().getItem(self.itemID, eager=('attributes', 'group.category'))
try:
fighter = Fighter(item)
except ValueError:
@@ -162,6 +162,36 @@ class FighterInfo:
return makeReprStr(self, ['itemID', 'amount', 'state', 'abilities'])
class ImplantInfo:
def __init__(self, itemID, state=None):
self.itemID = itemID
self.state = state
@classmethod
def fromImplant(cls, implant):
if implant is None:
return None
info = cls(
itemID=implant.itemID,
state=implant.active)
return info
def toImplant(self):
item = Market.getInstance().getItem(self.itemID, eager=('attributes', 'group.category'))
try:
implant = Implant(item)
except ValueError:
pyfalog.warning('Invalid item: {}'.format(self.itemID))
return None
if self.state is not None:
implant.active = self.state
return implant
def __repr__(self):
return makeReprStr(self, ['itemID', 'state'])
class BoosterInfo:
def __init__(self, itemID, state=None, sideEffects=None):
@@ -180,7 +210,7 @@ class BoosterInfo:
return info
def toBooster(self):
item = Market.getInstance().getItem(self.itemID)
item = Market.getInstance().getItem(self.itemID, eager=('attributes', 'group.category'))
try:
booster = Booster(item)
except ValueError:
@@ -197,36 +227,6 @@ class BoosterInfo:
return makeReprStr(self, ['itemID', 'state', 'sideEffects'])
class ImplantInfo:
def __init__(self, itemID, state=None):
self.itemID = itemID
self.state = state
@classmethod
def fromImplant(cls, implant):
if implant is None:
return None
info = cls(
itemID=implant.itemID,
state=implant.active)
return info
def toImplant(self):
item = Market.getInstance().getItem(self.itemID)
try:
implant = Implant(item)
except ValueError:
pyfalog.warning('Invalid item: {}'.format(self.itemID))
return None
if self.state is not None:
implant.active = self.state
return implant
def __repr__(self):
return makeReprStr(self, ['itemID', 'state'])
class CargoInfo:
def __init__(self, itemID, amount):