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

tacticalOverlay.py (11191B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\eve\client\script\parklife\tacticalOverlay.py
      2 import blue
      3 import uthread2
      4 from eve.client.script.parklife import states as stateConst
      5 from eve.common.lib import appConst as const
      6 from tacticalNavigation import ballparkFunctions as ballpark
      7 from tacticalNavigation import tacticalCompass
      8 from tacticalNavigation.ui import util as tacticalUI
      9 _HIDE_VELOCITY_CATEGORIES = [const.categoryAsteroid]
     10 
     11 class TacticalOverlay:
     12     _interestStates = [stateConst.targeting,
     13      stateConst.targeted,
     14      stateConst.mouseOver,
     15      stateConst.selected,
     16      stateConst.lookingAt]
     17     _aggressorStates = [stateConst.targeted,
     18      stateConst.threatTargetsMe,
     19      stateConst.threatAttackingMe,
     20      stateConst.flagOutlaw,
     21      stateConst.flagDangerous,
     22      stateConst.flagAtWarCanFight,
     23      stateConst.flagStandingBad,
     24      stateConst.flagStandingHorrible,
     25      stateConst.flagAtWarMilitia,
     26      stateConst.flagAlliesAtWar,
     27      stateConst.flagSuspect,
     28      stateConst.flagCriminal,
     29      stateConst.flagHasKillRight,
     30      stateConst.flagLimitedEngagement,
     31      stateConst.targeting]
     32     _friendlyStates = [stateConst.flagSameFleet,
     33      stateConst.flagSamePlayerCorp,
     34      stateConst.flagSameNpcCorp,
     35      stateConst.flagSameAlliance]
     36 
     37     def __init__(self, tactical, actionDisplay):
     38         self.tactical = tactical
     39         self.actionDisplay = actionDisplay
     40         self.tacticalCompass = None
     41         self.initialized = False
     42         self.initializing = False
     43         self.showingModuleRange = False
     44         self.selectedID = None
     45         self.selectedConnector = None
     46         self.rootPosition = None
     47         self.navBalls = []
     48         self._ballInterests = {}
     49         self._ballFriendly = {}
     50         self._ballAggressive = {}
     51 
     52     def Initialize(self):
     53         if self.initialized or self.initializing:
     54             return
     55         self.initializing = True
     56         self.tacticalCompass = tacticalCompass.TacticalCompass()
     57         self.InitConnectors()
     58         self.initialized = True
     59         self.initializing = False
     60         self.UpdateTargetingRange()
     61         self.OnShipChange()
     62         self.actionDisplay.EnableActionDisplay(True)
     63 
     64     def IsInitialized(self):
     65         return self.initialized
     66 
     67     def EnableMoveMode(self, curve):
     68         curveID = getattr(curve, 'id', None)
     69         if not self.initialized:
     70             return
     71         self.tacticalCompass.SetMoveMode(True, curve)
     72         if curveID == session.shipid or curve is None:
     73             return
     74         ego = ballpark.GetBall(session.shipid)
     75         if ego is not None:
     76             self.tacticalCompass.AddConnector(ego, True)
     77 
     78     def DisableMoveMode(self):
     79         if not self.initialized:
     80             return
     81         ego = ballpark.GetBall(session.shipid)
     82         self.RemoveConnector(session.shipid)
     83         self.tacticalCompass.SetMoveMode(False, ego)
     84 
     85     def RegisterNavBall(self, ball):
     86         if ball not in self.navBalls:
     87             self.navBalls.append(ball)
     88             self.tacticalCompass.AddConnector(ball, False)
     89 
     90     def UnregisterNavBall(self, ball):
     91         if ball in self.navBalls:
     92             self.navBalls.remove(ball)
     93             self.RemoveConnector(ball.id)
     94 
     95     def TearDown(self):
     96         if self.initialized:
     97             self._ClearSelection()
     98             self.tacticalCompass.ClearAll()
     99             self.initialized = False
    100             self.tacticalCompass = None
    101             self.actionDisplay.EnableActionDisplay(False)
    102 
    103     def _ShouldShowVelocity(self, slimItem):
    104         categoryID = getattr(slimItem, 'categoryID', None)
    105         return categoryID not in _HIDE_VELOCITY_CATEGORIES
    106 
    107     def AddConnector(self, ball, slimItem):
    108         if self.initialized:
    109             self.tacticalCompass.AddConnector(ball, self._ShouldShowVelocity(slimItem))
    110             self._CheckAggressionStates(ball)
    111 
    112     def HasConnector(self, ballID):
    113         if not self.initialized:
    114             return False
    115         return self.tacticalCompass.HasConnector(ballID) or ballID == self.selectedID or self._HasInterest(ballID)
    116 
    117     def RemoveConnector(self, ballID):
    118         if not self.initialized:
    119             return
    120         self.tacticalCompass.RemoveConnector(ballID)
    121         if ballID == self.selectedID:
    122             self._ClearSelection()
    123         self._ClearInterest(ballID)
    124 
    125     def _UpdateInterest(self, ballID, state, flag):
    126         if ballID not in self._ballInterests:
    127             if flag:
    128                 self._ballInterests[ballID] = set([state])
    129             return
    130         if not flag and state in self._ballInterests[ballID]:
    131             self._ballInterests[ballID].remove(state)
    132         if flag and state not in self._ballInterests[ballID]:
    133             self._ballInterests[ballID].add(state)
    134 
    135     def _HasInterest(self, ballID):
    136         return ballID in self._ballInterests or ballID in self._ballAggressive
    137 
    138     def _ClearInterest(self, ballID):
    139         if ballID in self._ballInterests:
    140             del self._ballInterests[ballID]
    141         if ballID in self._ballAggressive:
    142             del self._ballAggressive[ballID]
    143 
    144     def _IsInteresting(self, ballID):
    145         return ballID in self._ballInterests and len(self._ballInterests[ballID]) > 0
    146 
    147     def _CheckInterest(self, ballID, state, flag):
    148         if state not in self._interestStates:
    149             return
    150         if self.tacticalCompass is None:
    151             return
    152         self._UpdateInterest(ballID, state, flag)
    153         if self._IsInteresting(ballID):
    154             ball = ballpark.GetBall(ballID)
    155             if ball is None:
    156                 return
    157             bp = ballpark.GetBallpark()
    158             slimItem = None
    159             if bp is not None:
    160                 slimItem = bp.GetInvItem(ballID)
    161             self.tacticalCompass.AddConnector(ball, self._ShouldShowVelocity(slimItem))
    162         else:
    163             self._ClearInterest(ballID)
    164             bp = ballpark.GetBallpark()
    165             if bp is None:
    166                 return
    167             slimItem = bp.GetInvItem(ballID)
    168             filtered = self.tactical.GetFilteredStatesFunctionNames()
    169             alwaysShown = self.tactical.GetAlwaysShownStatesFunctionNames()
    170             if not self.tactical.WantIt(slimItem, filtered, alwaysShown):
    171                 self.RemoveConnector(ballID)
    172 
    173     def CheckState(self, ballID, state, flag):
    174         if not self.initialized or ballID == session.shipid:
    175             return
    176         if state == stateConst.selected and flag:
    177             self._ShowDirectionTo(ballID)
    178         self._CheckInterest(ballID, state, flag)
    179         self._CheckAggression(ballID, state, flag)
    180 
    181     def _CheckAggressionStates(self, ball):
    182         checkStates = self._GetMatchingStates(ball.id, self._aggressorStates)
    183         for state in checkStates:
    184             self._CheckAggression(ball.id, state, True)
    185 
    186     def _CheckAggression(self, ballID, state, flag):
    187         if state not in self._aggressorStates:
    188             return
    189         if not self.initialized:
    190             return
    191         aggressionStates = self._ballAggressive.get(ballID, [])
    192         if flag:
    193             if state not in aggressionStates:
    194                 aggressionStates.append(state)
    195         elif state in aggressionStates:
    196             aggressionStates.remove(state)
    197         self.tacticalCompass.SetAggressive(ballID, len(aggressionStates) > 0)
    198         self._ballAggressive[ballID] = aggressionStates
    199 
    200     def _GetMatchingStates(self, itemID, states):
    201         active = sm.GetService('stateSvc').GetStates(itemID, states)
    202         return [ x[1] for x in zip(active, states) if x[0] ]
    203 
    204     def InitConnectors(self):
    205         ballpark = sm.GetService('michelle').GetBallpark()
    206         if ballpark is None:
    207             return
    208         self.tacticalCompass.ClearConnectors()
    209         filtered = self.tactical.GetFilteredStatesFunctionNames()
    210         alwaysShown = self.tactical.GetAlwaysShownStatesFunctionNames()
    211         for itemID, ball in ballpark.balls.items():
    212             if itemID < 0 or itemID == session.shipid:
    213                 continue
    214             if ballpark is None:
    215                 break
    216             slimItem = ballpark.GetInvItem(itemID)
    217             if slimItem and self.tactical.WantIt(slimItem, filtered, alwaysShown):
    218                 self.tacticalCompass.AddConnector(ball, self._ShouldShowVelocity(slimItem))
    219             checkStates = self._GetMatchingStates(itemID, self._interestStates)
    220             checkStates.extend(self._GetMatchingStates(itemID, self._aggressorStates))
    221             for intrState in checkStates:
    222                 self.CheckState(itemID, intrState, True)
    223 
    224         for ball in self.navBalls:
    225             self.tacticalCompass.AddConnector(ball, False)
    226 
    227     def _ClearSelection(self):
    228         if self.selectedConnector is not None:
    229             self.selectedConnector.Destroy()
    230             self.selectedConnector = None
    231             self.tacticalCompass.SetInterest(None)
    232         self.selectedID = None
    233 
    234     def _ShowDirectionTo(self, ballID):
    235         if self.selectedID == ballID:
    236             return
    237         self._ClearSelection()
    238         targetBall = ballpark.GetBall(ballID)
    239         if targetBall is None:
    240             return
    241         self.tacticalCompass.SetInterest(targetBall)
    242         self.selectedConnector = tacticalUI.CreateStraightConnector(tacticalUI.STYLE_FAINT, tacticalUI.COLOR_GENERIC, None, targetBall)
    243         self.selectedID = ballID
    244 
    245     def OnShipChange(self):
    246         if not self.initialized:
    247             return
    248         ball = ballpark.GetBall(session.shipid)
    249         self.tacticalCompass.SetRootBall(ball)
    250 
    251     def UpdateTargetingRange(self):
    252 
    253         def _inner():
    254             while self.initialized:
    255                 if not session.shipid:
    256                     if self.tacticalCompass is not None:
    257                         self.tacticalCompass.compassDisc.HideFiringRange()
    258                 else:
    259                     ship = sm.GetService('godma').GetItem(session.shipid)
    260                     if self.tacticalCompass is not None:
    261                         self.tacticalCompass.SetTargetingRange(ship.maxTargetRange, not self.showingModuleRange)
    262                         self.actionDisplay.SetMaxMoveRange(self.tacticalCompass.GetMaxRange())
    263                 blue.synchro.SleepSim(1000)
    264 
    265         uthread2.StartTasklet(_inner)
    266 
    267     def UpdateModuleRange(self, module = None, charge = None):
    268         if not self.initialized or self.tacticalCompass is None:
    269             return
    270         self.showingModuleRange = module is not None
    271         self.tacticalCompass.HideBombRange()
    272         if module is None:
    273             self.tacticalCompass.compassDisc.HideFiringRange()
    274             return
    275         maxRange, falloff, bombRadius, cynoRadius = self.tactical.FindMaxRange(module, charge)
    276         if bombRadius:
    277             self.tacticalCompass.compassDisc.HideFiringRange()
    278             ball = ballpark.GetBall(session.shipid)
    279             self.tacticalCompass.ShowBombRange(bombRadius, maxRange, ball)
    280         elif cynoRadius:
    281             self.tacticalCompass.compassDisc.HideFiringRange()
    282             radius = getattr(ballpark.GetBall(session.shipid), 'radius', 0.0)
    283             self.tacticalCompass.ShowCynoRange(cynoRadius + radius)
    284         else:
    285             self.tacticalCompass.SetFiringRange(maxRange, falloff)