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

characterDogmaItem.py (9627B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\dogma\items\characterDogmaItem.py
      2 from __future__ import absolute_import
      3 from .fittableDogmaItem import FittableDogmaItem
      4 from utillib import strx, KeyVal
      5 import weakref
      6 import sys
      7 import log
      8 import dogma.const as dgmconst
      9 import inventorycommon.const as invconst
     10 from eve.common.script.sys.idCheckers import IsStation
     11 from ccpProfile import TimedFunction
     12 
     13 class CharacterDogmaItem(FittableDogmaItem):
     14 
     15     def __init__(self, dogmaLocation, item, eveCfg, clientIDFunc):
     16         FittableDogmaItem.__init__(self, dogmaLocation, item, eveCfg, clientIDFunc)
     17         self.fittedItems = {}
     18         self._activeShipID = None
     19 
     20     @property
     21     def activeShipID(self):
     22         return self._activeShipID
     23 
     24     @activeShipID.setter
     25     def activeShipID(self, activeShipID):
     26         if activeShipID is None and self._activeShipID is not None:
     27             log.LogTraceback('Active shipID is being set to None post initialization!')
     28             return
     29         self._activeShipID = activeShipID
     30 
     31     def GetOwnedItemsToModify(self):
     32         modItems = []
     33         for dogmaItem in self.ownedItems:
     34             if dogmaItem.IsOwnerModifiable():
     35                 modItems.append(dogmaItem)
     36 
     37         return modItems
     38 
     39     @TimedFunction('CharacterDogmaItem::Load')
     40     def Load(self, item, instanceRow):
     41         FittableDogmaItem.Load(self, item, instanceRow)
     42         attrs = self.attributes
     43         char = self.dogmaLocation.GetCharacter(item.itemID, flush=True)
     44         attrs[dgmconst.attributeIntelligence].SetBaseValue(char.intelligence)
     45         attrs[dgmconst.attributeCharisma].SetBaseValue(char.charisma)
     46         attrs[dgmconst.attributePerception].SetBaseValue(char.perception)
     47         attrs[dgmconst.attributeMemory].SetBaseValue(char.memory)
     48         attrs[dgmconst.attributeWillpower].SetBaseValue(char.willpower)
     49 
     50     def SetLocation(self, locationID, locationDogmaItem, flagID):
     51         if flagID != invconst.flagPilot:
     52             raise RuntimeError('CharacterDogmaItem::SetLocation - flag not pilot (%s, %s)' % (locationID, flagID))
     53         oldData = self.GetLocationInfo()
     54         oldShipID = self.activeShipID
     55         self.activeShipID = locationID
     56         self.flagID = flagID
     57         self.HandleLocationChange(oldShipID)
     58         return oldData
     59 
     60     def UnsetLocation(self, locationDogmaItem):
     61         locationDogmaItem.UnregisterPilot(self)
     62 
     63     def RegisterFittedItem(self, dogmaItem, flagID):
     64         self.dogmaLocation.moduleListsByShipGroup[self.itemID][dogmaItem.groupID].add(dogmaItem.itemID)
     65         self.dogmaLocation.moduleListsByShipType[self.itemID][dogmaItem.typeID].add(dogmaItem.itemID)
     66         self.fittedItems[dogmaItem.itemID] = weakref.proxy(dogmaItem)
     67 
     68     def UnregisterFittedItem(self, dogmaItem):
     69         groupID = dogmaItem.groupID
     70         typeID = dogmaItem.typeID
     71         itemID = dogmaItem.itemID
     72         try:
     73             self.dogmaLocation.moduleListsByShipGroup[self.itemID][groupID].remove(itemID)
     74         except KeyError:
     75             self.dogmaLocation.LogError("UnregisterFittedItem::Tried to remove item from mlsg but group wasn't there", strx(dogmaItem))
     76             sys.exc_clear()
     77         except IndexError:
     78             self.dogmaLocation.LogError("UnregisterFittedItem::Tried to remove item from mlsg but it wasn't there", strx(dogmaItem))
     79             sys.exc_clear()
     80 
     81         try:
     82             self.dogmaLocation.moduleListsByShipType[self.itemID][typeID].remove(itemID)
     83         except KeyError:
     84             self.dogmaLocation.LogError("UnregisterFittedItem::Tried to remove item from mlsg but type wasn't there", strx(dogmaItem))
     85             sys.exc_clear()
     86         except IndexError:
     87             self.dogmaLocation.LogError("UnregisterFittedItem::Tried to remove item from mlsg but it wasn't there", strx(dogmaItem))
     88             sys.exc_clear()
     89 
     90         try:
     91             del self.fittedItems[dogmaItem.itemID]
     92         except KeyError:
     93             self.dogmaLocation.LogError("UnregisterFittedItem::Tried to remove item from fittedItems but it wasn't there", strx(dogmaItem.itemID))
     94 
     95     def Unload(self):
     96         FittableDogmaItem.Unload(self)
     97         itemID = self.itemID
     98         shipID = self.dogmaLocation.shipsByPilotID.get(self.itemID, None)
     99         if shipID is None:
    100             self.dogmaLocation.LogError('Character %s unloading without having been put into a ship. State is not consistent!' % self.itemID)
    101         for itemKey in self.fittedItems.keys():
    102             self.dogmaLocation.UnloadItem(itemKey)
    103 
    104         if itemID in self.dogmaLocation.shipsByPilotID:
    105             del self.dogmaLocation.shipsByPilotID[itemID]
    106         if shipID in self.dogmaLocation.pilotsByShipID:
    107             del self.dogmaLocation.pilotsByShipID[shipID]
    108         if self.itemID in self.dogmaLocation.moduleListsByShipGroup:
    109             del self.dogmaLocation.moduleListsByShipGroup[self.itemID]
    110         if self.itemID in self.dogmaLocation.moduleListsByShipType:
    111             del self.dogmaLocation.moduleListsByShipType[self.itemID]
    112         if self.itemID in self.dogmaLocation.scarecrows:
    113             while self.dogmaLocation.scarecrows[self.itemID].queue > 0:
    114                 self.dogmaLocation.scarecrows[self.itemID].send(True)
    115 
    116     def OnItemLoaded(self):
    117         if not self.dogmaLocation.HasBrainData(self.itemID):
    118             self.dogmaLocation.InitBrain(self.itemID)
    119         initShipID = self.dogmaLocation.GetActiveShipID(self.itemID)
    120         if initShipID:
    121             self.dogmaLocation.OnCharacterEmbarkation(self.itemID, initShipID)
    122         FittableDogmaItem.OnItemLoaded(self)
    123 
    124     def CanFitItem(self, dogmaItem, flagID):
    125         if flagID == invconst.flagBooster:
    126             return True
    127         return False
    128 
    129     def ValidFittingFlag(self, flagID):
    130         if flagID == invconst.flagBooster:
    131             return True
    132         return False
    133 
    134     def GetFittedItems(self):
    135         return self.fittedItems
    136 
    137     def GetPersistables(self):
    138         ret = FittableDogmaItem.GetPersistables(self)
    139         ret.update(self.fittedItems.keys())
    140         return ret
    141 
    142     def _FlushEffects(self):
    143         with self.dogmaLocation.ignoredOwnerEvents.Event(self.itemID):
    144             stackTraceCount = 0
    145             for fittedItem in self.fittedItems.itervalues():
    146                 stackTraceCount += fittedItem.FlushEffects()
    147 
    148             stackTraceCount += FittableDogmaItem._FlushEffects(self)
    149         return stackTraceCount
    150 
    151     def GetPilot(self):
    152         return self.itemID
    153 
    154     def GetShipID(self):
    155         locationID = self.invItem.locationID
    156         if locationID > invconst.minPlayerItem:
    157             return self.dogmaLocation.shipsByPilotID[self.itemID]
    158 
    159     def GetCharacterID(self):
    160         return self.itemID
    161 
    162     def HandleLocationChange(self, oldShipID):
    163         newShipID = self.activeShipID
    164         shipByPilotID = self.dogmaLocation.shipsByPilotID.get(self.itemID, None)
    165         if self.dogmaLocation.locationGroup == invconst.groupStation:
    166             oldShipID = shipByPilotID
    167         if newShipID == oldShipID:
    168             self.dogmaLocation.LogInfo('%s: HandleLocationChange does not need to do anything for character %s who is already in location %s' % (self.dogmaLocation.locationID, self.itemID, oldShipID))
    169             return
    170         if shipByPilotID and oldShipID != shipByPilotID and oldShipID is not None:
    171             log.LogTraceback('%s: HandleLocationChange expected to find character %s in ship %s but found him in ship %s' % (self.dogmaLocation.locationID,
    172              self.itemID,
    173              oldShipID,
    174              shipByPilotID))
    175         self.dogmaLocation.LogInfo('%s: HandleLocationChange is changing location for character %s from %s to %s' % (self.dogmaLocation.locationID,
    176          self.itemID,
    177          oldShipID,
    178          newShipID))
    179         oldShipItem = self.dogmaLocation.dogmaItems.get(oldShipID, None)
    180         try:
    181             if self.dogmaLocation.pilotsByShipID.get(oldShipID) == self.itemID:
    182                 if oldShipItem:
    183                     oldShipItem.HandlePilotChange(None)
    184                     self._UnregisterAsOwnerForShipItems(oldShipItem)
    185                 del self.dogmaLocation.pilotsByShipID[oldShipID]
    186             self.dogmaLocation.shipsByPilotID[self.itemID] = newShipID
    187             self.dogmaLocation.pilotsByShipID[newShipID] = self.itemID
    188             super(CharacterDogmaItem, self).HandleLocationChange(oldShipID)
    189             newShipItem = self.dogmaLocation.dogmaItems.get(newShipID, None)
    190             if newShipItem:
    191                 newShipItem.RegisterPilot(self)
    192                 newShipItem.HandlePilotChange(self.itemID)
    193                 self._RegisterAsOwnerForShipItems(newShipItem)
    194         except Exception:
    195             self.dogmaLocation.shipsByPilotID[self.itemID] = oldShipID
    196             self.dogmaLocation.pilotsByShipID[oldShipID] = self.itemID
    197             if newShipID in self.dogmaLocation.pilotsByShipID:
    198                 del self.dogmaLocation.pilotsByShipID[newShipID]
    199             raise
    200 
    201     def _UnregisterAsOwnerForShipItems(self, oldShipItem):
    202         for item in oldShipItem.subItems:
    203             item.owner = None
    204             try:
    205                 self.ownedItems.remove(item)
    206             except KeyError:
    207                 self.dogmaLocation.LogError("item should have been registered as owned but wasn't", self.itemID, item.itemID, oldShipItem.itemID)
    208 
    209     def _RegisterAsOwnerForShipItems(self, newShipItem):
    210         for item in newShipItem.subItems:
    211             item.owner = weakref.proxy(self)
    212             self.ownedItems.add(item)
    213 
    214 
    215 class GhostCharacterDogmaItem(CharacterDogmaItem):
    216     __guid__ = 'GhostCharacterDogmaItem'