Source code for direct.distributed.DistributedObject

"""DistributedObject module: contains the DistributedObject class"""

from panda3d.core import *
from import *
from direct.directnotify.DirectNotifyGlobal import directNotify
from direct.distributed.DistributedObjectBase import DistributedObjectBase
#from PyDatagram import PyDatagram
#from PyDatagramIterator import PyDatagramIterator

# Values for DistributedObject.activeState

ESNew          = 1
ESDeleted      = 2
ESDisabling    = 3
ESDisabled     = 4  # values here and lower are considered "disabled"
ESGenerating   = 5  # values here and greater are considered "generated"
ESGenerated    = 6

# update this table if the values above change
ESNum2Str = {
    ESNew: 'ESNew',
    ESDeleted: 'ESDeleted',
    ESDisabling: 'ESDisabling',
    ESDisabled: 'ESDisabled',
    ESGenerating: 'ESGenerating',
    ESGenerated: 'ESGenerated',

[docs]class DistributedObject(DistributedObjectBase): """ The Distributed Object class is the base class for all network based (i.e. distributed) objects. These will usually (always?) have a dclass entry in a \\*.dc file. """ notify = directNotify.newCategory("DistributedObject") # A few objects will set neverDisable to 1... Examples are # localToon, and anything that lives in the UberZone. This # keeps them from being disabled when you change zones, # even to the quiet zone. neverDisable = 0
[docs] def __init__(self, cr): assert self.notify.debugStateCall(self) try: self.DistributedObject_initialized except: self.DistributedObject_initialized = 1 DistributedObjectBase.__init__(self, cr) # Most DistributedObjects are simple and require no real # effort to load. Some, particularly actors, may take # some significant time to load; these we can optimize by # caching them when they go away instead of necessarily # deleting them. The object should set cacheable to 1 if # it needs to be optimized in this way. self.setCacheable(0) # this is for Toontown only, see toontown.distributed.DelayDeletable self._token2delayDeleteName = {} self._delayDeleteForceAllow = False self._delayDeleted = 0 # Keep track of our state as a distributed object. This # is only trustworthy if the inheriting class properly # calls up the chain for disable() and generate(). self.activeState = ESNew # These are used by getCallbackContext() and doCallbackContext(). self.__nextContext = 0 self.__callbacks = {} # This is used by doneBarrier(). self.__barrierContext = None
if __debug__:
[docs] def status(self, indent=0): """ print out "doId(parentId, zoneId) className and conditionally show generated, disabled, neverDisable, or cachable" """ spaces = ' ' * (indent + 2) try: print("%s%s:" % (' ' * indent, self.__class__.__name__)) flags = [] if self.activeState == ESGenerated: flags.append("generated") if self.activeState < ESGenerating: flags.append("disabled") if self.neverDisable: flags.append("neverDisable") if self.cacheable: flags.append("cacheable") flagStr = "" if len(flags): flagStr = " (%s)" % (" ".join(flags)) print("%sfrom DistributedObject doId:%s, parent:%s, zone:%s%s" % ( spaces, self.doId, self.parentId, self.zoneId, flagStr)) except Exception as e: print("%serror printing status %s" % (spaces, e))
[docs] def getAutoInterests(self): # returns the sub-zones under this object that are automatically # opened for us by the server. # have we already cached it? def _getAutoInterests(cls): # returns set of auto-interests for this class and all derived # have we already computed this class's autoInterests? if 'autoInterests' in cls.__dict__: autoInterests = cls.autoInterests else: autoInterests = set() # grab autoInterests from base classes for base in cls.__bases__: autoInterests.update(_getAutoInterests(base)) # grab autoInterests from this class if cls.__name__ in dclass =[cls.__name__] field = dclass.getFieldByName('AutoInterest') if field is not None: p = DCPacker() p.setUnpackData(field.getDefaultValue()) len = p.rawUnpackUint16() // 4 for i in range(len): zone = int(p.rawUnpackUint32()) autoInterests.add(zone) autoInterests.update(autoInterests) cls.autoInterests = autoInterests return set(autoInterests) autoInterests = _getAutoInterests(self.__class__) # if the server starts supporting multiple auto-interest per class, this check # should be removed if len(autoInterests) > 1: self.notify.error( 'only one auto-interest allowed per DC class, %s has %s autoInterests (%s)' % (self.dclass.getName(), len(autoInterests), list(autoInterests))) _getAutoInterests = None return list(autoInterests)
[docs] def setNeverDisable(self, bool): assert bool == 1 or bool == 0 self.neverDisable = bool
[docs] def getNeverDisable(self): return self.neverDisable
def _retrieveCachedData(self): # once we know our doId, grab any data that might be stored in the data cache # from the last time we were on the client if self._cachedData =
[docs] def setCachedData(self, name, data): assert type(name) == type('') # ownership of the data passes to the repository data cache, name, data)
[docs] def hasCachedData(self, name): assert type(name) == type('') if not hasattr(self, '_cachedData'): return False return name in self._cachedData
[docs] def getCachedData(self, name): assert type(name) == type('') # ownership of the data passes to the caller of this method data = self._cachedData[name] del self._cachedData[name] return data
[docs] def flushCachedData(self, name): assert type(name) == type('') # call this to throw out cached data from a previous instantiation self._cachedData[name].flush()
[docs] def setCacheable(self, bool): assert bool == 1 or bool == 0 self.cacheable = bool
[docs] def getCacheable(self): return self.cacheable
[docs] def deleteOrDelay(self): if len(self._token2delayDeleteName) > 0: if not self._delayDeleted: self._delayDeleted = 1 # Object is delayDeleted. Clean up DistributedObject state, # remove from repository tables, so that we won't crash if # another instance of the same object gets generated while # this instance is still delayDeleted. messenger.send(self.getDelayDeleteEvent()) if len(self._token2delayDeleteName) > 0: self.delayDelete() if len(self._token2delayDeleteName) > 0: self._deactivateDO() else: self.disableAnnounceAndDelete()
[docs] def disableAnnounceAndDelete(self): self.disableAndAnnounce() self.delete() self._destroyDO()
[docs] def getDelayDeleteCount(self): return len(self._token2delayDeleteName)
[docs] def getDelayDeleteEvent(self): return self.uniqueName("delayDelete")
[docs] def getDisableEvent(self): return self.uniqueName("disable")
[docs] def disableAndAnnounce(self): """ Inheritors should *not* redefine this function. """ # We must send the disable announce message *before* we # actually disable the object. That way, the various cleanup # tasks can run first and take care of restoring the object to # a normal, nondisabled state; and *then* the disable function # can properly disable it (for instance, by parenting it to # hidden). if self.activeState != ESDisabled: self.activeState = ESDisabling messenger.send(self.getDisableEvent()) self.disable() self.activeState = ESDisabled if not self._delayDeleted: # if the object is DelayDeleted, _deactivateDO has # already been called self._deactivateDO()
[docs] def announceGenerate(self): """ Sends a message to the world after the object has been generated and all of its required fields filled in. """ assert self.notify.debug('announceGenerate(): %s' % (self.doId))
def _deactivateDO(self): # after this is called, the object is no longer an active DistributedObject # and it may be placed in the cache if not # we are going to crash, output the destroyDo stacktrace self.notify.warning(' is none in _deactivateDO %d' % self.doId) if hasattr(self, 'destroyDoStackTrace'): print(self.destroyDoStackTrace) self.__callbacks = {} self.setLocation(0,0), self.parentId, self.zoneId) def _destroyDO(self): # after this is called, the object is no longer a DistributedObject # but may still be used as a DelayDeleted object if __debug__: # StackTrace is omitted in packed versions from direct.showbase.PythonUtil import StackTrace self.destroyDoStackTrace = StackTrace() # check for leftover cached data that was not retrieved or flushed by this object # this will catch typos in the data name in calls to get/setCachedData if hasattr(self, '_cachedData'): for name, cachedData in self._cachedData.items(): self.notify.warning('flushing unretrieved cached data: %s' % name) cachedData.flush() del self._cachedData = None self.dclass = None
[docs] def disable(self): """ Inheritors should redefine this to take appropriate action on disable """ assert self.notify.debug('disable(): %s' % (self.doId)) pass
[docs] def isDisabled(self): """ Returns true if the object has been disabled and/or deleted, or if it is brand new and hasn't yet been generated. """ return (self.activeState < ESGenerating)
[docs] def isGenerated(self): """ Returns true if the object has been fully generated by now, and not yet disabled. """ assert self.notify.debugStateCall(self) return (self.activeState == ESGenerated)
[docs] def delete(self): """ Inheritors should redefine this to take appropriate action on delete """ assert self.notify.debug('delete(): %s' % (self.doId)) try: self.DistributedObject_deleted except: self.DistributedObject_deleted = 1
[docs] def generate(self): """ Inheritors should redefine this to take appropriate action on generate """ assert self.notify.debugStateCall(self) self.activeState = ESGenerating # this has already been set at this point, self.parentId, self.zoneId) # semi-hack: we seem to be calling generate() more than once for objects that multiply-inherit if not hasattr(self, '_autoInterestHandle'):
[docs] def generateInit(self): """ This method is called when the DistributedObject is first introduced to the world... Not when it is pulled from the cache. """ self.activeState = ESGenerating
[docs] def getDoId(self): """ Return the distributed object id """ return self.doId
#This message was moved out of announce generate #to avoid ordering issues.
[docs] def postGenerateMessage(self): if self.activeState != ESGenerated: self.activeState = ESGenerated messenger.send(self.uniqueName("generate"), [self])
[docs] def updateRequiredFields(self, dclass, di): dclass.receiveUpdateBroadcastRequired(self, di) self.announceGenerate() self.postGenerateMessage()
[docs] def updateAllRequiredFields(self, dclass, di): dclass.receiveUpdateAllRequired(self, di) self.announceGenerate() self.postGenerateMessage()
[docs] def updateRequiredOtherFields(self, dclass, di): # First, update the required fields dclass.receiveUpdateBroadcastRequired(self, di) # Announce generate after updating all the required fields, # but before we update the non-required fields. self.announceGenerate() self.postGenerateMessage() dclass.receiveUpdateOther(self, di)
[docs] def sendUpdate(self, fieldName, args = [], sendToId = None): if dg = self.dclass.clientFormatUpdate( fieldName, sendToId or self.doId, args) else: assert self.notify.error("sendUpdate failed, because is not set")
[docs] def sendDisableMsg(self):
[docs] def sendDeleteMsg(self):
[docs] def taskName(self, taskString): return ("%s-%s" % (taskString, self.doId))
[docs] def uniqueName(self, idString): return ("%s-%s" % (idString, self.doId))
[docs] def getCallbackContext(self, callback, extraArgs = []): # Some objects implement a back-and-forth handshake operation # with the AI via an arbitrary context number. This method # (coupled with doCallbackContext(), below) maps a Python # callback onto that context number so that client code may # easily call the method and wait for a callback, rather than # having to negotiate context numbers. # This method generates a new context number and stores the # callback so that it may later be called when the response is # returned. # This is intended to be called within derivations of # DistributedObject, not directly by other objects. context = self.__nextContext self.__callbacks[context] = (callback, extraArgs) # We assume the context number is passed as a uint16. self.__nextContext = (self.__nextContext + 1) & 0xffff return context
[docs] def getCurrentContexts(self): # Returns a list of the currently outstanding contexts created # by getCallbackContext(). return list(self.__callbacks.keys())
[docs] def getCallback(self, context): # Returns the callback that was passed in to the previous # call to getCallbackContext. return self.__callbacks[context][0]
[docs] def getCallbackArgs(self, context): # Returns the extraArgs that were passed in to the previous # call to getCallbackContext. return self.__callbacks[context][1]
[docs] def doCallbackContext(self, context, args): # This is called after the AI has responded to the message # sent via getCallbackContext(), above. The context number is # looked up in the table and the associated callback is # issued. # This is intended to be called within derivations of # DistributedObject, not directly by other objects. tuple = self.__callbacks.get(context) if tuple: callback, extraArgs = tuple completeArgs = args + extraArgs if callback != None: callback(*completeArgs) del self.__callbacks[context] else: self.notify.warning("Got unexpected context from AI: %s" % (context))
[docs] def setBarrierData(self, data): # This message is sent by the AI to tell us the barriers and # avIds for which the AI is currently waiting. The client # needs to look up its pending context in the table (and # ignore the other contexts). When the client is done # handling whatever it should handle in its current state, it # should call doneBarrier(), which will send the context # number back to the AI. for context, name, avIds in data: for avId in avIds: if # We found the local avatar's id; stop here. self.__barrierContext = (context, name) assert self.notify.debug('setBarrierData(%s, %s)' % (context, name)) return # This barrier didn't involve this client; ignore it. assert self.notify.debug('setBarrierData(%s)' % (None)) self.__barrierContext = None
[docs] def getBarrierData(self): # Return a trivially-empty (context, name, avIds) value. return ((0, '', []),)
[docs] def doneBarrier(self, name = None): # Tells the AI we have finished handling our task. If the # optional name parameter is specified, it must match the # barrier name specified on the AI, or the barrier is ignored. # This is used to ensure we are not clearing the wrong # barrier. # If this is None, it either means we have called # doneBarrier() twice, or we have not received a barrier # context from the AI. I think in either case it's ok to # silently ignore the error. if self.__barrierContext != None: context, aiName = self.__barrierContext if name == None or name == aiName: assert self.notify.debug('doneBarrier(%s, %s)' % (context, aiName)) self.sendUpdate("setBarrierReady", [context]) self.__barrierContext = None else: assert self.notify.debug('doneBarrier(%s) ignored; current barrier is %s' % (name, aiName)) else: assert self.notify.debug('doneBarrier(%s) ignored; no active barrier.' % (name))
[docs] def addInterest(self, zoneId, note="", event=None): return, zoneId, note, event)
[docs] def removeInterest(self, handle, event=None): return, event)
[docs] def b_setLocation(self, parentId, zoneId): self.d_setLocation(parentId, zoneId) self.setLocation(parentId, zoneId)
[docs] def d_setLocation(self, parentId, zoneId):, parentId, zoneId)
[docs] def setLocation(self, parentId, zoneId):, parentId, zoneId)
[docs] def getLocation(self): try: if self.parentId == 0 and self.zoneId == 0: return None # This is a -1 stuffed into a uint32 if self.parentId == 0xffffffff and self.zoneId == 0xffffffff: return None return (self.parentId, self.zoneId) except AttributeError: return None
[docs] def getParentObj(self): if self.parentId is None: return None return
[docs] def isLocal(self): # This returns true if the distributed object is "local," # which means the client created it instead of the AI, and it # gets some other special handling. Normally, only the local # avatar class overrides this to return true. return and
[docs] def isGridParent(self): # If this distributed object is a DistributedGrid return 1. 0 by default return 0
[docs] def execCommand(self, string, mwMgrId, avId, zoneId): pass