NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

turretSet.py (15481B)


      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\eve\client\script\environment\model\turretSet.py
      2 import remotefilecache
      3 import inventorycommon.typeHelpers
      4 import trinity
      5 import blue
      6 import log
      7 import evetypes
      8 import evegraphics.settings as gfxsettings
      9 from eve.common.script.sys import eveCfg
     10 from stacklesslib.util import block_trap
     11 from fsdBuiltData.common.graphicIDs import GetGraphic, GetGraphicFile, GetAmmoColor
     12 import inventorycommon.const as const
     13 from eve.client.script.environment.sofService import GetSofService
     14 LOCATOR_MOONHARVESTER = 'locator_moonharvester_'
     15 LOCATOR_TURRET = 'locator_turret_'
     16 
     17 def GetTurretSetCount(model, turretTypeID):
     18     try:
     19         graphicId = evetypes.GetGraphicID(turretTypeID)
     20     except evetypes.TypeNotFoundException:
     21         return 0
     22 
     23     if not graphicId:
     24         return 0
     25     turret = trinity.Load(GetGraphicFile(graphicId))
     26     if turret is None or not isinstance(turret, trinity.EveTurretSet):
     27         return 0
     28     locators = [ loc for loc in model.locators if loc.name.startswith(turret.locatorName) ]
     29     if len(locators) == 0:
     30         locators = [ loc for loc in model.locators if loc.name.startswith(LOCATOR_TURRET) ]
     31     locatorSets = {filter(str.isdigit, loc.name) for loc in locators}
     32     return len(locatorSets)
     33 
     34 
     35 class TurretSet(object):
     36     turretsEnabled = [False]
     37 
     38     def Initialize(self, graphics, locator, overrideBeamGraphicID = None, count = 1, swarmID = 0):
     39         self.inWarp = False
     40         self.isShooting = False
     41         self.targetsAvailable = False
     42         self.online = True
     43         self.targetID = None
     44         self.turretTypeID = 0
     45         self.turretGroupID = 0
     46         self.turretSets = []
     47         if not hasattr(graphics, 'graphicFile'):
     48             log.LogError('No turret redfile defined for: ' + str(graphics))
     49             return self.turretSets
     50         turretPath = graphics.graphicFile
     51         for i in range(count):
     52             tSet = trinity.Load(turretPath)
     53             if tSet is None:
     54                 continue
     55             if len(tSet.locatorName) == 0:
     56                 tSet.locatorName = LOCATOR_TURRET
     57             elif tSet.locatorName[-1].isdigit():
     58                 tSet.locatorName = tSet.locatorName[:-1]
     59             if locator < 0:
     60                 tSet.slotNumber = i + 1
     61             elif tSet.locatorName == LOCATOR_MOONHARVESTER:
     62                 tSet.slotNumber = 1
     63             else:
     64                 tSet.slotNumber = locator
     65             tSet.swarmID = swarmID
     66             self.turretSets.append(tSet)
     67 
     68         for turretSet in self.turretSets:
     69             turretFxPath = turretSet.firingEffectResPath
     70             try:
     71                 effect = blue.recycler.RecycleOrLoad(turretFxPath)
     72             except RuntimeError:
     73                 log.LogError('Could not load firing effect ' + turretFxPath + ' for turret: ' + turretPath)
     74                 effect = None
     75 
     76             turretSet.firingEffect = effect
     77 
     78         return self.turretSets
     79 
     80     def __del__(self):
     81         for turretSet in self.turretSets:
     82             for stretch in turretSet.firingEffect.stretch:
     83                 if hasattr(stretch, 'sourceSpaceObject'):
     84                     stretch.sourceSpaceObject = None
     85                 if hasattr(stretch, 'destSpaceObject'):
     86                     stretch.destSpaceObject = None
     87 
     88     def RemoveTurretFromModel(self, model):
     89         for tSet in self.turretSets:
     90             model.turretSets.remove(tSet)
     91 
     92     def GetTurretSet(self, index = 0):
     93         return self.turretSets[index]
     94 
     95     def GetTurretSets(self):
     96         return self.turretSets
     97 
     98     def Release(self):
     99         pass
    100 
    101     def SetTargetsAvailable(self, available):
    102         if self.targetsAvailable and not available:
    103             self.Rest()
    104         self.targetsAvailable = available
    105 
    106     def SetTarget(self, targetID):
    107         self.targetID = targetID
    108         targetBall = sm.GetService('michelle').GetBall(targetID)
    109         if targetBall is not None:
    110             targetModel = getattr(targetBall, 'model', None)
    111             if targetModel is not None:
    112                 for turretSet in self.turretSets:
    113                     turretSet.targetObject = targetBall.model
    114 
    115             else:
    116                 self.targetID = None
    117 
    118     def SetAmmoColorByTypeID(self, ammoTypeID):
    119         gfxid = evetypes.GetGraphicID(ammoTypeID)
    120         ammoColor = GetAmmoColor(gfxid)
    121         if ammoColor is not None:
    122             color = tuple(ammoColor)
    123             self.SetAmmoColor(color)
    124 
    125     def SetDestSpaceObject(self, targetModel):
    126         for turretSet in self.turretSets:
    127             for stretch in turretSet.firingEffect.stretch:
    128                 if hasattr(stretch, 'destSpaceObject'):
    129                     stretch.destSpaceObject = targetModel
    130 
    131     def SetSourceSpaceObject(self, sourceModel):
    132         for turretSet in self.turretSets:
    133             for stretch in turretSet.firingEffect.stretch:
    134                 if hasattr(stretch, 'sourceSpaceObject'):
    135                     stretch.sourceSpaceObject = sourceModel
    136 
    137     def SetAmmoColor(self, color):
    138         if color is None:
    139             return
    140         for curve in self.GetCurveConstants('Ammo'):
    141             curve.value = color
    142 
    143     def StartControllers(self):
    144         for turretSet in self.turretSets:
    145             turretSet.StartControllers()
    146 
    147     def SetControllerVariable(self, name, value):
    148         for turretSet in self.turretSets:
    149             turretSet.SetControllerVariable(name, value)
    150 
    151     def SetIntensity(self, intensity):
    152         for curve in self.GetCurveConstants('py_intensity'):
    153             curve.value = (intensity,
    154              curve.value[1],
    155              curve.value[2],
    156              curve.value[3])
    157 
    158     def GetCurveConstants(self, name):
    159         curves = []
    160         for turretSet in self.turretSets:
    161             if turretSet.firingEffect is not None:
    162                 for curve in turretSet.firingEffect.Find('trinity.Tr2CurveConstant'):
    163                     if curve.name == name:
    164                         curves.append(curve)
    165 
    166         return curves
    167 
    168     def IsShooting(self):
    169         return self.isShooting
    170 
    171     def StartShooting(self, ignoreTarget = False):
    172         if self.inWarp:
    173             return
    174         if self.targetID is None and ignoreTarget is not True:
    175             return
    176         for turretSet in self.turretSets:
    177             turretSet.EnterStateFiring()
    178 
    179         self.isShooting = True
    180 
    181     def StopShooting(self):
    182         for turretSet in self.turretSets:
    183             if self.inWarp:
    184                 turretSet.EnterStateDeactive()
    185             elif self.targetsAvailable:
    186                 turretSet.EnterStateTargeting()
    187             else:
    188                 turretSet.EnterStateIdle()
    189 
    190         self.isShooting = False
    191 
    192     def Rest(self):
    193         if self.inWarp or not self.online:
    194             return
    195         for turretSet in self.turretSets:
    196             turretSet.EnterStateIdle()
    197 
    198     def Offline(self):
    199         if self.online == False:
    200             return
    201         self.online = False
    202         for turretSet in self.turretSets:
    203             turretSet.isOnline = False
    204             turretSet.EnterStateDeactive()
    205 
    206     def Online(self):
    207         if self.online:
    208             return
    209         self.online = True
    210         for turretSet in self.turretSets:
    211             turretSet.isOnline = True
    212             turretSet.EnterStateIdle()
    213 
    214     def Reload(self):
    215         for turretSet in self.turretSets:
    216             turretSet.EnterStateReloading()
    217 
    218     def EnterWarp(self):
    219         self.inWarp = True
    220         for turretSet in self.turretSets:
    221             turretSet.EnterStateDeactive()
    222 
    223     def ExitWarp(self):
    224         self.inWarp = False
    225         if self.online:
    226             for turretSet in self.turretSets:
    227                 turretSet.EnterStateIdle()
    228 
    229     def TakeAim(self, targetID):
    230         if self.targetID != targetID:
    231             return
    232         if not self.online:
    233             return
    234         for turretSet in self.turretSets:
    235             turretSet.EnterStateTargeting()
    236 
    237     @staticmethod
    238     def _isFittableTurret(type, group):
    239         if group in const.turretModuleGroups:
    240             return True
    241         if type in (const.typeTriglavianArmorRepairModule1,
    242          const.typeTriglavianArmorRepairModule2,
    243          const.typeTriglavianArmorRepairModule3,
    244          const.typeTriglavianArmorRepairModule4,
    245          const.typeTriglavianArmorRepairModule5):
    246             return True
    247         return False
    248 
    249     @staticmethod
    250     def AddTurretToModel(model, turretGraphicsID, turretFaction = None, locatorID = 1, count = 1, swarmID = 0, turretTypeID = None):
    251         if not hasattr(model, 'turretSets'):
    252             log.LogError('Wrong object is trying to get turret attached due to wrong authored content! model:' + model.name + ' bluetype:' + model.__bluetype__)
    253             return
    254         graphics = GetGraphic(turretGraphicsID)
    255         if turretTypeID is not None and evetypes.GetGroupID(turretTypeID) == const.groupStructureMoonDrillingServiceModule:
    256             newTurretSet = StructureMoonMiningTurretSet()
    257         else:
    258             newTurretSet = TurretSet()
    259         eveTurretSets = newTurretSet.Initialize(graphics, locatorID, None, count=count, swarmID=swarmID)
    260         spaceObjectFactory = GetSofService().spaceObjectFactory
    261         for tSet in eveTurretSets:
    262             if model.dna:
    263                 spaceObjectFactory.SetupTurretMaterialFromDNA(tSet, model.dna)
    264             elif turretFaction is not None:
    265                 spaceObjectFactory.SetupTurretMaterialFromFaction(tSet, turretFaction)
    266             model.turretSets.append(tSet)
    267 
    268         return newTurretSet
    269 
    270     @staticmethod
    271     def FitTurret(model, turretTypeID, locatorID, turretFaction = None, count = 1, online = True, checkSettings = True):
    272         if not evetypes.Exists(turretTypeID):
    273             return
    274         if checkSettings and not gfxsettings.Get(gfxsettings.UI_TURRETS_ENABLED):
    275             return
    276         groupID = evetypes.GetGroupID(turretTypeID)
    277         if model is None:
    278             log.LogError('FitTurret() called with NoneType, so there is no model to fit the turret to!')
    279             return
    280         if not TurretSet._isFittableTurret(turretTypeID, groupID):
    281             return
    282         newTurretSet = None
    283         graphicID = evetypes.GetGraphicID(turretTypeID)
    284         if graphicID is not None:
    285             newTurretSet = TurretSet.AddTurretToModel(model, graphicID, turretFaction, locatorID, count, turretTypeID=turretTypeID)
    286             if newTurretSet is None:
    287                 return
    288             if not online:
    289                 newTurretSet.Offline()
    290             newTurretSet.turretTypeID = turretTypeID
    291             newTurretSet.turretGroupID = groupID
    292         return newTurretSet
    293 
    294     @staticmethod
    295     def PrefetchGraphicsForModules(modules):
    296         prefetch_set = set()
    297         for moduleID, typeID, slot, isOnline, count in modules:
    298             if not evetypes.Exists(typeID):
    299                 continue
    300             if evetypes.Exists(typeID) and evetypes.GetGroupID(typeID) not in const.turretModuleGroups:
    301                 continue
    302             turretPath = inventorycommon.typeHelpers.GetGraphicFile(typeID)
    303             if turretPath:
    304                 prefetch_set.add(turretPath)
    305 
    306         remotefilecache.prefetch_files(prefetch_set)
    307 
    308     @staticmethod
    309     def GetSlotFromModuleFlagID(flagID):
    310         if flagID in const.hiSlotFlags:
    311             return flagID - const.flagHiSlot0 + 1
    312         elif flagID in const.medSlotFlags:
    313             return flagID - const.flagMedSlot0 + 1
    314         else:
    315             return -1
    316 
    317     @staticmethod
    318     def FitTurrets(shipID, model, shipFaction = None):
    319         if not hasattr(model, 'turretSets'):
    320             return {}
    321         if not gfxsettings.Get(gfxsettings.UI_TURRETS_ENABLED):
    322             return {}
    323         turretsFitted = {}
    324         modules = []
    325         if shipID == eveCfg.GetActiveShip():
    326             dogmaLocation = sm.GetService('clientDogmaIM').GetDogmaLocation()
    327             if not dogmaLocation.IsItemLoaded(shipID):
    328                 return {}
    329             dogmaLocation.LoadItem(shipID)
    330             ship = dogmaLocation.GetDogmaItem(shipID)
    331             modules = []
    332             for module in ship.GetFittedItems().itervalues():
    333                 slot = TurretSet.GetSlotFromModuleFlagID(module.flagID)
    334                 if module.groupID in const.turretModuleGroups:
    335                     modules.append([module.itemID,
    336                      module.typeID,
    337                      slot,
    338                      module.IsOnline(),
    339                      1])
    340 
    341         else:
    342             bp = sm.StartService('michelle').GetBallpark()
    343             slimItem = bp.GetInvItem(shipID) if bp else None
    344             if slimItem is not None:
    345                 for itemID, typeID, flagID in slimItem.modules:
    346                     slot = TurretSet.GetSlotFromModuleFlagID(flagID)
    347                     modules.append([itemID,
    348                      typeID,
    349                      slot,
    350                      True,
    351                      1])
    352 
    353                 if len(modules) == 0:
    354                     godma = sm.GetService('godma')
    355                     godmaStateManager = godma.GetStateManager()
    356                     godmaType = godmaStateManager.GetType(slimItem.typeID)
    357                     if godmaType.gfxTurretID > 0:
    358                         turretCount = GetTurretSetCount(model, godmaType.gfxTurretID)
    359                         if turretCount != 0:
    360                             modules.append([shipID,
    361                              godmaType.gfxTurretID,
    362                              -1,
    363                              True,
    364                              turretCount])
    365         TurretSet.PrefetchGraphicsForModules(modules)
    366         with block_trap():
    367             del model.turretSets[:]
    368             modules = sorted(modules, key=lambda x: x[2])
    369             locatorCounter = 1
    370             for moduleID, typeID, slot, isOnline, count in modules:
    371                 slot = slot or locatorCounter
    372                 ts = TurretSet.FitTurret(model, typeID, slot, shipFaction, online=isOnline, count=count)
    373                 if ts is not None:
    374                     turretsFitted[moduleID] = ts
    375                     locatorCounter += count
    376 
    377             return turretsFitted
    378 
    379 
    380 class StructureMoonMiningTurretSet(TurretSet):
    381 
    382     def __init__(self):
    383         self.moonID = None
    384 
    385     def Initialize(self, graphics, locator, overrideBeamGraphicID = None, count = 1, swarmID = 0):
    386         turretSets = super(StructureMoonMiningTurretSet, self).Initialize(graphics, locator, overrideBeamGraphicID, count, swarmID)
    387         self.Display(False)
    388         return turretSets
    389 
    390     def SetMoonID(self, moonID):
    391         if moonID == self.moonID:
    392             return
    393         self.moonID = moonID
    394         self.SetTarget(moonID)
    395         self.TakeAim(moonID)
    396         self.Display()
    397 
    398     def Display(self, display = True):
    399         for ts in self.turretSets:
    400             ts.display = display
    401 
    402     def Rest(self):
    403         self.TakeAim(self.moonID)
    404 
    405     def Offline(self):
    406         pass
    407 
    408     def Online(self):
    409         super(StructureMoonMiningTurretSet, self).Online()
    410         self.TakeAim(self.moonID)
    411 
    412     def SetTarget(self, targetID):
    413         alreadyTargetted = any([ ts.targetObject is not None for ts in self.turretSets ])
    414         if targetID == self.moonID and not alreadyTargetted:
    415             super(StructureMoonMiningTurretSet, self).SetTarget(targetID)
    416 
    417     def TakeAim(self, targetID):
    418         if self.targetID != targetID:
    419             return
    420         if not self.online:
    421             return
    422         for turretSet in self.turretSets:
    423             turretSet.ForceStateTargeting()