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

hackingUISvc.py (15320B)


      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\eve\client\script\ui\hacking\hackingUISvc.py
      2 import random
      3 import blue
      4 import log
      5 from carbon.common.script.sys.service import Service
      6 from eve.client.script.ui.hacking import hackingUIConst
      7 from eve.client.script.ui.hacking.hackingTileData import TileData
      8 from eve.client.script.ui.hacking.hackingUtilityElementData import UtilityElementData
      9 from eve.client.script.ui.hacking.hackingWindow import HackingWindow
     10 import hackingcommon.hackingConstants as hackingConst
     11 
     12 class HackingSvc(Service):
     13     __guid__ = 'svc.hackingUI'
     14     __servicename__ = 'hackingUI'
     15     __displayname__ = 'Hacking UI'
     16     __notifyevents__ = ['OnHackingTurnComplete']
     17     __dependencies__ = []
     18 
     19     def Run(self, *args):
     20         self.game = None
     21         self.gameType = None
     22         self.selectedUtilElement = None
     23         self.virusID = None
     24         self.hackingMgr = sm.RemoteSvc('hackingMgr')
     25         self.tileDataByCoord = {}
     26         self.utilityElements = []
     27         self.virusStrength = None
     28         self.virusCoherence = None
     29         self.gameEnded = True
     30         self.difficulty = 1
     31         self.virusInitialCoherence = 200
     32         self.virusInitialStrength = 30
     33         self.virusSlots = 3
     34 
     35     def SetDifficulty(self, difficulty):
     36         self.difficulty = difficulty
     37 
     38     def SetVirusStats(self, coherence, strength, slots):
     39         self.virusInitialCoherence = coherence
     40         self.virusInitialStrength = strength
     41         self.virusSlots = slots
     42 
     43     def TriggerNewGame(self):
     44         import random
     45         self._ResetGameInfo()
     46         self.gameType = random.choice((hackingConst.GAMETYPE_HACKING, hackingConst.GAMETYPE_ARCHEOLOGY))
     47         self.hackingMgr.StartNewGameInstance(None, self.gameType, 22329, self.difficulty, self.virusInitialCoherence, self.virusInitialStrength, self.virusSlots)
     48 
     49     def QuitHackingAttempt(self):
     50         self.hackingMgr.QuitHackingAttempt()
     51 
     52     def OnHackingTurnComplete(self, events):
     53         startEvents = [ event for event in events if event['eventID'] == hackingConst.EVENT_GAME_START ]
     54         if len(startEvents) > 0:
     55             self._OpenWindowOrReloadIfGameEnded()
     56         self._GameEventHandler(events)
     57 
     58     def _OpenWindowOrReloadIfGameEnded(self):
     59         if self.gameEnded:
     60             window = HackingWindow.GetIfOpen()
     61             if not window:
     62                 self._ResetGameInfo()
     63                 HackingWindow.Open()
     64             else:
     65                 self._ResetGameInfo()
     66                 HackingWindow.Reload(window)
     67 
     68     def _ResetGameInfo(self):
     69         random.seed()
     70         self.gameEnded = False
     71         self.tileDataByCoord = {}
     72         self.utilityElements = []
     73 
     74     def _GameEventHandler(self, events):
     75         for event in events:
     76             eventID = event['eventID']
     77             if eventID == hackingConst.EVENT_GAME_WON:
     78                 sm.ScatterEvent('OnHackingWon')
     79                 sm.GetService('audio').SendUIEvent('minigame_win')
     80                 self.gameEnded = True
     81             elif eventID == hackingConst.EVENT_GAME_LOST:
     82                 sm.ScatterEvent('OnHackingLost')
     83                 sm.GetService('audio').SendUIEvent('minigame_loose')
     84                 sm.GetService('audio').SendUIEvent('minigame_stop')
     85                 self.gameEnded = True
     86             elif eventID == hackingConst.EVENT_GAME_START:
     87                 self.ConstructTileDataNeighbours()
     88                 sm.ScatterEvent('OnHackingStart', event['eventData'])
     89                 if self.gameType == hackingConst.GAMETYPE_HACKING:
     90                     sm.GetService('audio').SendUIEvent('minigame_type_hack')
     91                 elif self.gameType == hackingConst.GAMETYPE_ARCHEOLOGY:
     92                     sm.GetService('audio').SendUIEvent('minigame_type_arch')
     93             elif eventID == hackingConst.EVENT_GAME_STYLE:
     94                 self.gameType = event['eventData']['style']
     95             elif eventID in (hackingConst.EVENT_TILE_FLIPPED,
     96              hackingConst.EVENT_TILE_BLOCKED,
     97              hackingConst.EVENT_DATACACHE_OPEN,
     98              hackingConst.EVENT_KERNALROT):
     99                 eventData = event['eventData']
    100                 if eventID == hackingConst.EVENT_TILE_FLIPPED:
    101                     type = eventData['type']
    102                     if type == hackingConst.TYPE_SEGMENT:
    103                         sm.GetService('audio').SendUIEvent('minigame_click_unexp_nothing')
    104                     elif type == hackingConst.TYPE_DEFENSESOFTWARE:
    105                         sm.GetService('audio').SendUIEvent('minigame_click_unexp_defence')
    106                         sm.ScatterEvent('OnDefenseSoftwareUnveiled', eventData['coord'])
    107                     elif type == hackingConst.TYPE_CORE:
    108                         sm.GetService('audio').SendUIEvent('minigame_click_unexp_goal')
    109                         sm.ScatterEvent('OnCoreUnveiled', eventData['coord'])
    110                     elif type == hackingConst.TYPE_DATACACHE:
    111                         sm.GetService('audio').SendUIEvent('minigame_click_unexp_treasure')
    112                     elif type == hackingConst.TYPE_UTILITYELEMENTTILE:
    113                         sm.GetService('audio').SendUIEvent('minigame_click_data_utility')
    114                 elif eventID == hackingConst.EVENT_DATACACHE_OPEN:
    115                     type = eventData['type']
    116                     if type == hackingConst.TYPE_DEFENSESOFTWARE:
    117                         sm.ScatterEvent('OnDefenseSoftwareUnveiled', eventData['coord'])
    118                         sm.GetService('audio').SendUIEvent('minigame_click_data_defence')
    119                     else:
    120                         sm.GetService('audio').SendUIEvent('minigame_click_data_utility')
    121                 self.HandleTileUpdatedEvent(eventID, eventData)
    122             elif eventID == hackingConst.EVENT_TILE_CREATED:
    123                 eventData = event['eventData']
    124                 tileData = TileData(**eventData)
    125                 if tileData.coord in self.tileDataByCoord:
    126                     if not self.gameEnded:
    127                         log.LogException('Hacking: Attempting to add tile to a coordinate that already contains a tile.')
    128                 self.tileDataByCoord[tileData.coord] = tileData
    129                 sm.ScatterEvent('OnHackingTileCreated', tileData, eventData)
    130             elif eventID == hackingConst.EVENT_ATTACK:
    131                 self.HandleAttackEvent(event['eventData'], eventID)
    132                 if event['eventData']['defenderResult']['coherence'] == 0:
    133                     sm.GetService('audio').SendUIEvent('minigame_kill')
    134                 else:
    135                     sm.GetService('audio').SendUIEvent('minigame_use_utility_other')
    136             elif eventID == hackingConst.EVENT_VIRUS_CREATED:
    137                 eventData = event['eventData']
    138                 self.virusID = eventData['id']
    139                 self.HandleVirusStatsChangedEvent(eventData, eventID)
    140                 self.ConstructUtilityElements(eventData['inventory'])
    141             elif eventID == hackingConst.EVENT_UE_PICKEDUP:
    142                 self.HandleUEPickedUpEvent(event['eventData'])
    143                 sm.GetService('audio').SendUIEvent('minigame_inventory_add')
    144             elif eventID == hackingConst.EVENT_UE_REMOVED:
    145                 eventData = event['eventData']
    146                 if self.utilityElements[eventData['index']].subtype == hackingConst.SUBTYPE_UE_POLYMORPHICSHIELD:
    147                     sm.GetService('audio').SendUIEvent('minigame_shield_end')
    148                 self.HandleUtilityElementsChanged(eventData['inventory']['inventory'])
    149                 sm.GetService('audio').SendUIEvent('minigame_use_utility_you')
    150             elif event['eventID'] == hackingConst.EVENT_UE_INUSE:
    151                 eventData = event['eventData']
    152                 if self.utilityElements[eventData['index']].subtype == hackingConst.SUBTYPE_UE_POLYMORPHICSHIELD:
    153                     sm.GetService('audio').SendUIEvent('minigame_shield')
    154                 self.utilityElements[eventData['index']].isInUse = bool(eventData['value'])
    155                 sm.ScatterEvent('OnHackingUEInventoryChanged')
    156             elif eventID == hackingConst.EVENT_SELFREPAIR:
    157                 sm.GetService('audio').SendUIEvent('minigame_use_utility_self')
    158                 eventData = event['eventData']
    159                 self.utilityElements[eventData['index']].durationRemaining = eventData['durationRemaining']
    160                 sm.ScatterEvent('OnHackingUEInventoryChanged')
    161                 self.HandleVirusStatsChangedEvent(eventData['target'], eventID)
    162             elif eventID == hackingConst.EVENT_OBJECT_KILLED:
    163                 eventData = event['eventData']
    164                 if eventData['type'] == hackingConst.TYPE_VIRUS:
    165                     self.HandleVirusStatsChangedEvent(eventData, eventID)
    166                 else:
    167                     self.HandleTileUpdatedEvent(eventID, eventData)
    168             elif eventID == hackingConst.EVENT_POLYMORPHICSHIELDHIT:
    169                 eventData = event['eventData']
    170                 self.utilityElements[eventData['index']].durationRemaining = eventData['durationRemaining']
    171                 sm.GetService('audio').SendUIEvent('minigame_use_utility_self')
    172                 sm.ScatterEvent('OnHackingUEInventoryChanged')
    173                 sm.ScatterEvent('OnHackingUEDurationReduced', eventData['index'], None)
    174             elif eventID == hackingConst.EVENT_SECONDARYVECTOR:
    175                 sm.GetService('audio').SendUIEvent('minigame_use_utility_other')
    176                 eventData = event['eventData']
    177                 self.utilityElements[eventData['index']].durationRemaining = eventData['durationRemaining']
    178                 self.HandleTileUpdatedEvent(eventID, eventData)
    179                 sm.ScatterEvent('OnHackingUEInventoryChanged')
    180                 sm.ScatterEvent('OnHackingUEDurationReduced', eventData['index'], eventData['coord'])
    181             elif eventID == hackingConst.EVENT_HONEYPOT_STRENGTH:
    182                 sm.GetService('audio').SendUIEvent('minigame_defencepowerup')
    183                 eventData = event['eventData']
    184                 self.HandleVirusStatsChangedEvent(eventData['virus'], eventID)
    185             elif eventID == hackingConst.EVENT_HONEYPOT_HEALING:
    186                 sm.GetService('audio').SendUIEvent('minigame_defencepowerup')
    187                 eventData = event['eventData']
    188                 sm.ScatterEvent('OnHoneyPotHealed', eventData['coord'], eventData['healedObject']['coord'], eventData['healingAmount'])
    189                 self.HandleTileUpdatedEvent(eventID, eventData['healedObject'])
    190             elif eventID == hackingConst.EVENT_CORE_CONTENTS:
    191                 eventData = event['eventData']
    192                 sm.ScatterEvent('OnCoreContentsRevealed', eventData['coord'], eventData['contentsList'])
    193             elif eventID == hackingConst.EVENT_DISTANCEINDICATOR:
    194                 eventData = event['eventData']
    195                 self.HandleTileUpdatedEvent(eventID, eventData)
    196             if eventID in hackingUIConst.EVENTS_SLEEP and len(events) > 1:
    197                 blue.synchro.SleepWallclock(hackingUIConst.EVENTS_SLEEP[eventID])
    198             else:
    199                 blue.synchro.Yield()
    200 
    201     def ConstructUtilityElements(self, inventory):
    202         for i, element in enumerate(inventory):
    203             elementData = UtilityElementData(index=i, **element)
    204             self.utilityElements.append(elementData)
    205 
    206         sm.ScatterEvent('OnHackingUEInventoryConstructed', self.utilityElements)
    207 
    208     def HandleTileUpdatedEvent(self, eventID, eventData):
    209         tileData = self.tileDataByCoord[eventData['coord']]
    210         tileData.Update(**eventData)
    211         sm.ScatterEvent('OnHackingTileChanged', eventID, tileData)
    212 
    213     def HandleUEPickedUpEvent(self, eventData):
    214         coord = eventData['coord']
    215         replacementObject = eventData['replacementObject']
    216         inventoryContents = eventData['inventory']
    217         self.HandleTileUpdatedEvent(hackingConst.EVENT_UE_PICKEDUP, replacementObject)
    218         self.HandleUtilityElementsChanged(inventoryContents)
    219 
    220     def HandleAttackEvent(self, eventData, eventID):
    221         attacker = eventData['attackerResult']
    222         defender = eventData['defenderResult']
    223         if attacker['type'] == hackingConst.TYPE_VIRUS:
    224             self.HandleVirusStatsChangedEvent(attacker, eventID)
    225         else:
    226             self.HandleTileUpdatedEvent(hackingConst.EVENT_ATTACK, attacker)
    227         if defender['type'] == hackingConst.TYPE_VIRUS:
    228             self.HandleVirusStatsChangedEvent(defender, eventID)
    229         else:
    230             self.HandleTileUpdatedEvent(hackingConst.EVENT_ATTACK, defender)
    231 
    232     def HandleVirusStatsChangedEvent(self, eventData, eventID):
    233         self.virusStrength = eventData['strength']
    234         self.virusCoherence = eventData['coherence']
    235         sm.ScatterEvent('OnHackingVirusChanged', eventData, eventID)
    236 
    237     def GetVirusStrengthAndCoherence(self):
    238         return (self.virusStrength, self.virusCoherence)
    239 
    240     def HandleUtilityElementsChanged(self, inventoryContents):
    241         for i, element in enumerate(inventoryContents):
    242             self.utilityElements[i].Update(**element)
    243 
    244         sm.ScatterEvent('OnHackingUEInventoryChanged')
    245 
    246     def OnTileClicked(self, tileCoord):
    247         if self.selectedUtilElement is not None:
    248             self.hackingMgr.UsedUtilityElement(self.selectedUtilElement, tileCoord)
    249             if self.tileDataByCoord[tileCoord].type not in (hackingConst.TYPE_CORE, hackingConst.TYPE_DEFENSESOFTWARE):
    250                 sm.GetService('audio').SendUIEvent('minigame_error')
    251             self.SetSelectedUtilElement(None)
    252         else:
    253             if self.tileDataByCoord[tileCoord].blocked:
    254                 sm.GetService('audio').SendUIEvent('minigame_error')
    255             self.hackingMgr.ClickedOnTile(tileCoord)
    256 
    257     def OnUtilityElementClicked(self, index, utilData):
    258         if index == self.selectedUtilElement:
    259             self.SetSelectedUtilElement(None)
    260         elif utilData.subtype in hackingConst.UE_SUBTYPES_APPLIED_TO_VIRUS:
    261             sm.GetService('audio').SendUIEvent('minigame_inventory_add')
    262             self.hackingMgr.UsedUtilityElementOnVirus(index)
    263         elif utilData.subtype in hackingConst.UE_SUBTYPES_APPLIED_TO_TARGET:
    264             sm.GetService('audio').SendUIEvent('minigame_inventory_add')
    265             self.SetSelectedUtilElement(index)
    266 
    267     def SetSelectedUtilElement(self, index = None):
    268         self.selectedUtilElement = index
    269         for i, uiData in enumerate(self.utilityElements):
    270             uiData.isSelected = i == self.selectedUtilElement
    271 
    272         sm.ScatterEvent('OnSelectedUtilityElementChanged', index)
    273 
    274     def ConstructTileDataNeighbours(self):
    275         for tileData in self.tileDataByCoord.values():
    276             neighbourTileData = self.GetTileNeighbours(tileData)
    277             tileData.SetNeighbours(neighbourTileData)
    278 
    279     def GetTileNeighbours(self, tileData):
    280         ret = []
    281         if tileData.coord[1] % 2:
    282             offsets = hackingUIConst.NEIGHBOR_OFFSETS1
    283         else:
    284             offsets = hackingUIConst.NEIGHBOR_OFFSETS2
    285         for dx, dy in offsets:
    286             coord = (tileData.coord[0] + dx, tileData.coord[1] + dy)
    287             if coord in self.tileDataByCoord:
    288                 ret.append(coord)
    289 
    290         return [ self.tileDataByCoord[coord] for coord in ret ]
    291 
    292     def SetTileHint(self, hint = None):
    293         wnd = HackingWindow.GetIfOpen()
    294         if wnd:
    295             wnd.SetTileHint(hint)