def setOccupied(self, avId):
        self.notify.debug('%d setOccupied: %d' % (self.doId, avId))
        if self.av != None:
            self.finishMovie()
            if not self.av.isEmpty() and not self.av.isDisabled():
                self.av.loop('neutral')
                self.av.setParent(ToontownGlobals.SPRender)
                self.av.startSmooth()
            self.finishMovie()
            if self.kart:
                self.kart.delete()
                self.kart = None
            if self.kartNode:
                self.kartNode.removeNode()
                self.kartNode = None
            self.placedAvatar = 0
            self.ignore(self.av.uniqueName('disable'))
            self.av = None
        wasLocalToon = self.localToonKarting
        self.lastAvId = self.avId
        self.lastFrame = globalClock.getFrameCount()
        self.avId = avId
        self.localToonKarting = 0
        if self.avId == 0:
            self.collSphere.setTangible(0)
            self.request('Off')
        else:
            self.collSphere.setTangible(1)
            av = self.cr.doId2do.get(self.avId)
            self.placedAvatar = 0
            if self.avId == base.localAvatar.doId:
                self.localToonKarting = 1
            if av != None:
                self.av = av
                self.av.stopSmooth()
                self.placedAvatar = 0
                self.acceptOnce(self.av.uniqueName('disable'),
                                self.__avatarGone)
                self.kartNode = render.attachNewNode(
                    self.av.uniqueName('KartNode'))
                self.kartNode.setPosHpr(self.nodePath.getPos(render),
                                        self.nodePath.getHpr(render))
                self.kart = Kart()
                self.kart.baseScale = 1.6
                self.kart.setDNA(self.av.getKartDNA())
                self.kart.generateKart()
                self.kart.resetGeomPos()
                self.av.wrtReparentTo(self.nodePath)
                self.av.setAnimState('neutral', 1.0)
                if not self.localToonKarting:
                    av.stopSmooth()
                    self.__placeAvatar()
                self.avParent = av.getParent()
            else:
                self.notify.warning('Unknown avatar %d in kart block %d ' %
                                    (self.avId, self.doId))
                self.avId = 0
        if wasLocalToon and not self.localToonKarting:
            place = base.cr.playGame.getPlace()
            if place:
                if self.exitRequested:
                    place.setState('walk')
                else:

                    def handleDialogOK(self=self):
                        self.ignore('stoppedAsleep')
                        place.setState('walk')
                        self.dialog.ignoreAll()
                        self.dialog.cleanup()
                        del self.dialog

                    doneEvent = 'kickedOutDialog'
                    msg = TTLocalizer.StartingBlock_KickSoloRacer
                    self.dialog = TTGlobalDialog(msg, doneEvent, style=1)
                    self.dialog.accept(doneEvent, handleDialogOK)
                    self.accept('stoppedAsleep', handleDialogOK)
        return
Esempio n. 2
0
    def setOccupied(self, avId):
        """
        """

        self.notify.debug("%d setOccupied: %d" % (self.doId, avId))

        # Check if there is a current avatar in the spot.
        if (self.av != None):

            # make sure any movies playing are done
            self.finishMovie()

            if (not self.av.isEmpty() and not self.av.isDisabled()):
                self.av.loop('neutral')
                self.av.setParent(ToontownGlobals.SPRender)
                self.av.startSmooth()

            # make sure any movies playing are done
            self.finishMovie()

            if self.kart:
                self.kart.delete()
                self.kart = None

            # remove the kart node
            if self.kartNode:
                self.kartNode.removeNode()
                self.kartNode = None

            self.placedAvatar = 0
            self.ignore(self.av.uniqueName("disable"))
            self.av = None

        assert self.kart == None

        # Store avatar and frame information
        wasLocalToon = self.localToonKarting
        self.lastAvId = self.avId
        self.lastFrame = globalClock.getFrameCount()

        # Update new information
        self.avId = avId
        self.localToonKarting = 0

        if (self.avId == 0):
            # The Kart Block is now available.
            self.collSphere.setTangible(0)
            self.request("Off")
        else:
            # The Kart block is now occupied; no one else may be here.
            self.collSphere.setTangible(1)
            av = self.cr.doId2do.get(self.avId)
            self.placedAvatar = 0

            if (self.avId == base.localAvatar.doId):
                self.localToonKarting = 1

            if (av != None):
                self.av = av
                self.av.stopSmooth()
                self.placedAvatar = 0

                self.acceptOnce(self.av.uniqueName("disable"),
                                self.__avatarGone)

                # Create a kart node
                self.kartNode = render.attachNewNode(
                    self.av.uniqueName('KartNode'))
                self.kartNode.setPosHpr(self.nodePath.getPos(render),
                                        self.nodePath.getHpr(render))

                # Create the kart
                assert self.kart == None
                self.kart = Kart()
                self.kart.baseScale = 1.6
                self.kart.setDNA(self.av.getKartDNA())

                # Generate the actual kart.
                self.kart.generateKart()
                self.kart.resetGeomPos()

                # Parent the Avatar to the kart block.
                self.av.wrtReparentTo(self.nodePath)
                self.av.setAnimState('neutral', 1.0)
                if not self.localToonKarting:
                    av.stopSmooth()
                    self.__placeAvatar()
                self.avParent = av.getParent()
            else:
                self.notify.warning("Unknown avatar %d in kart block %d " %
                                    (self.avId, self.doId))
                # make sure we don't try to play any movies here, but
                # let the next setOccupied (to 0 hopefully) reset
                # the starting block
                self.avId = 0

        # If the local toon was involved but is no longer, restore
        # walk mode.  We do this down here, after we have twiddled
        # with the tangible flag, so that the toon must walk out and
        # walk back in again in order to generate the enter event
        # again.
        if wasLocalToon and not self.localToonKarting:
            # Reset to walk mode, but not if we're exiting all the way
            # out (and our place is already gone).
            place = base.cr.playGame.getPlace()
            if place:
                # check to see if the toon requested the exit, or was booted
                if self.exitRequested:
                    place.setState('walk')
                else:
                    # the toon was booted off the block
                    def handleDialogOK(self=self):
                        self.ignore("stoppedAsleep")
                        place.setState("walk")
                        self.dialog.ignoreAll()
                        self.dialog.cleanup()
                        del self.dialog

                    doneEvent = 'kickedOutDialog'
                    msg = TTLocalizer.StartingBlock_KickSoloRacer
                    self.dialog = TTGlobalDialog(msg, doneEvent, style=1)
                    self.dialog.accept(doneEvent, handleDialogOK)

                    # make dialog go away if they fall asleep while stopped
                    self.accept("stoppedAsleep", handleDialogOK)