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

EffectController.py (8174B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\eve\client\script\environment\effects\EffectController.py
      2 from eve.client.script.environment.effects.GenericEffect import GenericEffect, STOP_REASON_DEFAULT, STOP_REASON_BALL_REMOVED
      3 from tacticalNavigation.ballparkFunctions import AddClientBallLocal, RemoveClientBall
      4 import blue
      5 import trinity
      6 import uthread
      7 import logging
      8 log = logging.getLogger(__name__)
      9 
     10 class ControllerEffect(GenericEffect):
     11     targetControllerState = 'notSet'
     12 
     13     def Stop(self, reason = STOP_REASON_DEFAULT):
     14         shipID = self.ballIDs[0]
     15         shipBall = self.fxSequencer.GetBall(shipID)
     16         shipBall.SetControllerVariable(self.targetControllerState, False)
     17 
     18     def Start(self, duration):
     19         shipID = self.ballIDs[0]
     20         shipBall = self.fxSequencer.GetBall(shipID)
     21         shipBall.SetControllerVariable(self.targetControllerState, True)
     22 
     23     def Repeat(self, duration):
     24         pass
     25 
     26 
     27 class SiegeMode(ControllerEffect):
     28     __guid__ = 'effects.SiegeMode'
     29     targetControllerState = 'InSiegeMode'
     30 
     31 
     32 class AttackMode(ControllerEffect):
     33     __guid__ = 'effects.AttackMode'
     34     targetControllerState = 'InAttackingMode'
     35 
     36 
     37 class ControllerTrigger(GenericEffect):
     38     __guid__ = 'effects.ControllerTrigger'
     39     controllerVariables = []
     40 
     41     def __init__(self, trigger, effect = None, graphicFile = None):
     42         super(ControllerTrigger, self).__init__(trigger, effect, graphicFile)
     43         shipID = self.ballIDs[0]
     44         ball = self.fxSequencer.GetBall(shipID)
     45         self.triggers = None
     46         self.isLoaded = False
     47         self.model = self.ExtractModel(graphicFile, ball)
     48         if ball is not None:
     49             self.targetBallModel = ball.model
     50         self.ball = None
     51         self.lingerOnDeathTime = trigger.graphicInfo.get('deathTimer') or 0.0
     52         self.SetUpControllerVariableTriggers(trigger)
     53 
     54     def SetUpControllerVariableTriggers(self, trigger):
     55         if hasattr(trigger, 'controllerVariableTriggers') and trigger.controllerVariableTriggers is not None:
     56             self.triggers = trigger.controllerVariableTriggers.items()
     57         if trigger.graphicInfo is not None:
     58             for i, (name, value) in enumerate(self.triggers):
     59                 if trigger.graphicInfo.get(name) is not None:
     60                     attributeOverride = trigger.graphicInfo.get(name)
     61                     self.triggers[i] = tuple([name, attributeOverride])
     62 
     63     def ExtractModel(self, graphicFile, targetBall):
     64         model = None
     65         if targetBall is not None and hasattr(targetBall, 'model'):
     66             if graphicFile is None:
     67                 model = targetBall.model
     68                 self.isLoaded = True
     69             else:
     70                 model = self.RecycleOrLoad(self.graphicFile)
     71                 if targetBall is None or targetBall.model is None or not hasattr(targetBall.model, 'worldPosition'):
     72                     return model
     73                 self.ball = AddClientBallLocal(targetBall.model.worldPosition)
     74                 model.translationCurve = targetBall
     75         return model
     76 
     77     def Start(self, duration):
     78         if self.model is None:
     79             return
     80         if not self.isLoaded:
     81             self.AddToScene(self.model)
     82         if hasattr(self.model, 'controllers'):
     83             secondsFromStart = self.timeFromStart / float(const.SEC)
     84             self.model.SetControllerVariable('elapsedTime', secondsFromStart)
     85             self.TriggerAttributes()
     86             self.model.StartControllers()
     87 
     88     def Stop(self, reason = STOP_REASON_DEFAULT):
     89         scene = self.fxSequencer.GetScene()
     90         if reason == STOP_REASON_BALL_REMOVED:
     91             if self.lingerOnDeathTime is not None:
     92                 uthread.new(ControllerTrigger._DelayedCleanUp, self.lingerOnDeathTime, self.model, self.ball, scene)
     93         else:
     94             self._CleanUp(self.model, self.ball, scene)
     95 
     96     @staticmethod
     97     def _DelayedCleanUp(timeInSec, model, ball, scene):
     98         blue.synchro.SleepSim(timeInSec * 1000)
     99         ControllerTrigger._CleanUp(model, ball, scene)
    100 
    101     @staticmethod
    102     def _CleanUp(model, ball, scene):
    103         if scene is not None and model is not None:
    104             scene.objects.fremove(model)
    105         if ball is not None:
    106             RemoveClientBall(ball)
    107 
    108     def Repeat(self, duration):
    109         if hasattr(self.model, 'controllers'):
    110             self.TriggerAttributes()
    111 
    112     def TriggerAttributes(self):
    113         if not self.triggers or self.model is None:
    114             return
    115         for name, value in self.triggers:
    116             self.model.SetControllerVariable(name, float(value))
    117             if hasattr(self, 'targetBallModel'):
    118                 if not self.isLoaded and self.targetBallModel is not None:
    119                     self.targetBallModel.SetControllerVariable(name, float(value))
    120 
    121     def UpdateGraphicInfo(self, newGraphicInfo):
    122         super(ControllerTrigger, self).UpdateGraphicInfo(newGraphicInfo)
    123         if newGraphicInfo is not None:
    124             for i, (name, value) in enumerate(self.triggers):
    125                 if newGraphicInfo.get(name) is not None:
    126                     attributeOverride = newGraphicInfo.get(name)
    127                     self.triggers[i] = tuple([name, attributeOverride])
    128 
    129         self.TriggerAttributes()
    130 
    131 
    132 class MultiEffectControllerTrigger(ControllerTrigger):
    133     __guid__ = 'effects.MultiEffectControllerTrigger'
    134     controllerVariables = []
    135 
    136     def __init__(self, trigger, effect = None, graphicFile = None):
    137         super(MultiEffectControllerTrigger, self).__init__(trigger, effect, graphicFile)
    138         if trigger.shipID is not None:
    139             if hasattr(self.model, 'name'):
    140                 shipID = str(trigger.shipID)
    141                 if self.model.name is not None:
    142                     self.model.name = self.model.name + '_' + shipID
    143                 elif graphicFile is not None:
    144                     self.model.name = graphicFile.split('.')[0].split('/')[-1] + '_' + shipID
    145         self.AssignMultiEffectParameters(trigger.graphicInfo)
    146         self.ConfigureModelRotationAndTranslationCurves()
    147 
    148     def ExtractModel(self, graphicFile, targetBall):
    149         if graphicFile is not None:
    150             model = self.RecycleOrLoad(self.graphicFile)
    151             if isinstance(model, trinity.EveMultiEffect):
    152                 return model
    153             log.warning("file loaded is not a multiEffect: '%s'" % graphicFile)
    154 
    155     def AssignMultiEffectParameters(self, graphicInfo):
    156         MultiEffectParams = []
    157         if self.model is not None:
    158             for param in self.model.parameters:
    159                 MultiEffectParams.append(param.name)
    160 
    161         for paramName in MultiEffectParams:
    162             targetId = graphicInfo.get(paramName)
    163             model = None
    164             if targetId is None:
    165                 log.warning("Could not find GraphicInfo parameter for MultiEffect param '%s'" % paramName)
    166                 continue
    167             ball = self.fxSequencer.GetBall(int(targetId))
    168             if ball is not None and hasattr(ball, 'model'):
    169                 model = ball.model
    170             if model is None:
    171                 log.warning("Could not find a model on ball to assign to MultiEffect param.  ballId: '%s'" % targetId)
    172                 continue
    173             MEP = self.model.parameters.FindByName(paramName)
    174             if MEP is not None:
    175                 MEP.object = model
    176 
    177     def ConfigureModelRotationAndTranslationCurves(self):
    178         if self.model is not None:
    179             for param in self.model.parameters:
    180                 if param.object is not None:
    181                     if hasattr(param.object, 'modelRotationCurve') and param.object.modelRotationCurve is None:
    182                         rotationAdapter = trinity.Tr2RotationAdapter()
    183                         if rotationAdapter is not None:
    184                             param.object.modelRotationCurve = rotationAdapter
    185                     if hasattr(param.object, 'modelTranslationCurve') and param.object.modelTranslationCurve is None:
    186                         translationAdapter = trinity.Tr2CurveVector3()
    187                         if translationAdapter is not None:
    188                             param.object.modelTranslationCurve = translationAdapter