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
     self.cr = None
     self.dclass = None
Exemple #2
0
 def delete(self):
     if not self.factoryGone:
         try:
             self.setBattleCellIndex(None)
         except Exception, e:
             simbase.air.writeServerEvent(
                 'avoid_crash', self.doId,
                 'DistributedFactorySuitAI.delete, factoryIsNotGone, got Exception %s'
                 % str(e))
             self.notify.warning(
                 'delete, factoryIsNotGone, got Exception %s' % str(e))
             self.notify.warning('stackTrace=%s' % StackTrace().compact())
             self.notify.warning('doId=%s' % self.doId)
             if hasattr(self, 'levelDoId'):
                 self.notify.warning('levelDoId=%s' % self.levelDoId)
             else:
                 self.notify.warning('no levelDoId')
    def _Cannon__cleanupToonInside(self):
        toonName = 'None'
        if self.toonInside:
            toonName = self.toonInside.getName()

        self.notify.debug('__cleanupToonInside self.toonInside=%s\nstack=%s' %
                          (toonName, StackTrace().compact()))
        if self.toonHead != None:
            self.hideToonHead()
            if hasattr(self.toonInside, 'nametag'):
                self.toonInside.nametag.removeNametag(self.toonHead.tag)

            self.toonHead.delete()
            self.toonHead = None

        self.toonInside = None
        self.toonParentNode = None
Exemple #4
0
    def __setToonInside(self, toon):
        self.toonInside = toon
        toonName = "None"
        if toon:
            toonName = toon.getName()
        self.notify.debug("__setToonInside self.toonInside=%s\nstack=%s" %
                          (toonName, StackTrace().compact()))
        self.toonInside.stopSmooth()
        self.toonOriginalScale = toon.getScale()

        # force use of highest LOD
        toon.useLOD(1000)
        # stick the toon under an additional node
        # in order to move the toon's local origin to its waist

        self.toonParentNode = render.attachNewNode("toonOriginChange")
        self.toonInside.wrtReparentTo(self.toonParentNode)
        self.toonInside.setPosHpr(0, 0, -(self.toonInside.getHeight() / 2.0),
                                  0, -90, 0)
    def unload(self):
        if self.avatar:
            self.avatar.reconsiderCheesyEffect()
        self.__clearCurrentItem()
        if hasattr(self, 'frame'):
            self.frame.destroy()
            del self.frame
            self.frameDelStackTrace = StackTrace()
        else:
            self.notify.warning('unload, no self.frame')
        if hasattr(self, 'mailbox'):
            del self.mailbox
        else:
            self.notify.warning('unload, no self.mailbox')
        if self.dialogBox:
            self.dialogBox.cleanup()
            self.dialogBox = None
        for item in self.items:
            if isinstance(item, CatalogItem.CatalogItem):
                item.acceptItemCleanup()

        self.ignoreAll()
Exemple #6
0
    def unload(self):
        assert (MailboxScreen.notify.debug("unload"))
        self.__clearCurrentItem()
        if hasattr(self, "frame"):
            self.frame.destroy()
            del self.frame
            self.frameDelStackTrace = StackTrace()
        else:
            self.notify.warning("unload, no self.frame")
        if hasattr(self, "mailbox"):
            del self.mailbox
        else:
            self.notify.warning("unload, no self.mailbox")

        if self.dialogBox:
            self.dialogBox.cleanup()
            self.dialogBox = None

        # Clean up all the items also.
        for item in self.items:
            if isinstance(item, CatalogItem.CatalogItem):
                item.acceptItemCleanup()

        self.ignoreAll()
 def __setToonInside(self, toon):
     self.toonInside = toon
     toonName = 'None'
     if toon:
         toonName = toon.getName()
     self.notify.debug('__setToonInside self.toonInside=%s\nstack=%s' % (toonName, StackTrace().compact()))
     self.toonInside.stopSmooth()
     self.toonOriginalScale = toon.getScale()
     toon.useLOD(1000)
     self.toonParentNode = render.attachNewNode('toonOriginChange')
     self.toonInside.wrtReparentTo(self.toonParentNode)
     self.toonInside.setPosHpr(0, 0, -(self.toonInside.getHeight() / 2.0), 0, -90, 0)
    def _doDeleteCleanup(self):
        self.trickLogger.destroy()
        self.trickFailLogger.destroy()
        self.feedLogger.destroy()
        self.scratchLogger.destroy()
        del self.trickLogger
        del self.trickFailLogger
        del self.feedLogger
        del self.scratchLogger
        taskMgr.remove(self.uniqueName('clearMovie'))
        taskMgr.remove(self.uniqueName('PetMovieWait'))
        taskMgr.remove(self.uniqueName('PetMovieClear'))
        taskMgr.remove(self.uniqueName('PetMovieComplete'))
        taskMgr.remove(self.getLockMoveTaskName())
        taskMgr.remove(self.getMoveTaskName())
        if hasattr(self, 'zoneId'):
            self.announceZoneChange(ToontownGlobals.QuietZone, self.zoneId)
        else:
            myDoId = 'No doId'
            myTaskName = 'No task name'
            myStackTrace = StackTrace().trace
            myOldStackTrace = 'No Trace'
            if hasattr(self, 'doId'):
                myDoId = self.doId
            if task:
                myTaskName = task.name
            if hasattr(self, 'destroyDoStackTrace'):
                myOldStackTrace = self.destroyDoStackTrace.trace
            simbase.air.writeServerEvent('Pet RequestDelete duplicate', myDoId,
                                         'from task %s' % myTaskName)
            simbase.air.writeServerEvent(
                'Pet RequestDelete duplicate StackTrace', myDoId,
                '%s' % myStackTrace)
            simbase.air.writeServerEvent(
                'Pet RequestDelete duplicate OldStackTrace', myDoId,
                '%s' % myOldStackTrace)
            DistributedPetAI.notify.warning(
                'double requestDelete from task %s' % myTaskName)
        self.setParent(ToontownGlobals.SPHidden)
        if hasattr(self, 'activated'):
            if self.activated:
                self.activated = 0
                self.brain.destroy()
                del self.brain
                self.actionFSM.destroy()
                del self.actionFSM
                self.exitPetLook()
                self.destroyImpulses()
                self.mover.destroy()
                del self.mover
                self.lockMover.destroy()
                del self.lockMover
                self.stopPosHprBroadcast()
        if hasattr(self, 'mood'):
            self.mood.destroy()
            del self.mood
        if hasattr(self, 'traits'):
            del self.traits
        try:
            for funcName in self.__funcsToDelete:
                del self.__dict__[funcName]

        except:
            pass

        if hasattr(self, 'gaitFSM'):
            if self.gaitFSM:
                self.gaitFSM.requestFinalState()
            del self.gaitFSM
        if hasattr(self, 'unstickFSM'):
            if self.unstickFSM:
                self.unstickFSM.requestFinalState()
            del self.unstickFSM
        if __dev__:
            del self.pscMoveResc
        PetLookerAI.PetLookerAI.destroy(self)
        self.ignoreAll()
        self._hasCleanedUp = True