Esempio n. 1
0
    def rejectEnter(self, errCode):
        """
        """
        self.notify.debugStateCall(self)

        def handleTicketError(self=self):
            self.ignore("stoppedAsleep")
            self.dialog.ignoreAll()
            self.dialog.cleanup()
            del self.dialog
            self.cr.playGame.getPlace().setState("walk")

        doneEvent = 'errorCode|dialog'
        if (errCode == KartGlobals.ERROR_CODE.eTickets):
            msg = TTLocalizer.StartingBlock_NotEnoughTickets
            self.dialog = TTGlobalDialog(msg, doneEvent, 2)
            self.dialog.accept(doneEvent, handleTicketError)
            # make dialog go away if they fall asleep while stopped
            self.accept("stoppedAsleep", handleTicketError)
        elif (errCode == KartGlobals.ERROR_CODE.eBoardOver):
            msg = TTLocalizer.StartingBlock_NoBoard
            self.dialog = TTGlobalDialog(msg, doneEvent, 2)
            self.dialog.accept(doneEvent, handleTicketError)
            # make dialog go away if they fall asleep while stopped
            self.accept("stoppedAsleep", handleTicketError)
        elif (errCode == KartGlobals.ERROR_CODE.eNoKart):
            msg = TTLocalizer.StartingBlock_NoKart
            self.dialog = TTGlobalDialog(msg, doneEvent, 2)
            self.dialog.accept(doneEvent, handleTicketError)
            # make dialog go away if they fall asleep while stopped
            self.accept("stoppedAsleep", handleTicketError)
        elif (errCode == KartGlobals.ERROR_CODE.eOccupied):
            msg = TTLocalizer.StartingBlock_Occupied
            self.dialog = TTGlobalDialog(msg, doneEvent, 2)
            self.dialog.accept(doneEvent, handleTicketError)
            # make dialog go away if they fall asleep while stopped
            self.accept("stoppedAsleep", handleTicketError)
        elif (errCode == KartGlobals.ERROR_CODE.eTrackClosed):
            msg = TTLocalizer.StartingBlock_TrackClosed
            self.dialog = TTGlobalDialog(msg, doneEvent, 2)
            self.dialog.accept(doneEvent, handleTicketError)
            # make dialog go away if they fall asleep while stopped
            self.accept("stoppedAsleep", handleTicketError)
        elif (errCode == KartGlobals.ERROR_CODE.eUnpaid):
            self.dialog = TeaserPanel(pageName="karting",
                                      doneFunc=handleTicketError)
        else:
            self.cr.playGame.getPlace().setState("walk")
    def __handleEnterSphere(self, collEntry):
        if base.localAvatar.doId == self.lastAvId and globalClock.getFrameCount(
        ) <= self.lastFrame + 1:
            self.notify.debug('Ignoring duplicate entry for avatar.')
            return
        if base.localAvatar.hp > 0:

            def handleEnterRequest(self=self):
                self.ignore('stoppedAsleep')
                if hasattr(self.dialog,
                           'doneStatus') and self.dialog.doneStatus == 'ok':
                    self.d_requestEnter()
                elif self.cr and not self.isDisabled():
                    self.cr.playGame.getPlace().setState('walk')
                else:
                    self.notify.warning(
                        'Warning! Object has already been disabled.')
                self.dialog.ignoreAll()
                self.dialog.cleanup()
                del self.dialog

            self.cr.playGame.getPlace().fsm.request('stopped')
            self.accept('stoppedAsleep', handleEnterRequest)
            doneEvent = 'enterRequest|dialog'
            if self.kartPad.isPractice():
                msg = TTLocalizer.StartingBlock_EnterPractice
            else:
                raceName = TTLocalizer.KartRace_RaceNames[
                    self.kartPad.trackType]
                numTickets = RaceGlobals.getEntryFee(self.kartPad.trackId,
                                                     self.kartPad.trackType)
                msg = TTLocalizer.StartingBlock_EnterNonPractice % (raceName,
                                                                    numTickets)
            self.dialog = TTGlobalDialog(msg, doneEvent, 4)
            self.dialog.accept(doneEvent, handleEnterRequest)
Esempio n. 3
0
    def _DistributedViewingBlock__handleEnterSphere(self, collEntry):
        if base.localAvatar.doId == self.lastAvId and globalClock.getFrameCount(
        ) <= self.lastFrame + 1:
            self.notify.debug('Ignoring duplicate entry for avatar.')
            return None

        if base.localAvatar.hp > 0:

            def handleEnterRequest(self=self):
                self.ignore('stoppedAsleep')
                if hasattr(self.dialog,
                           'doneStatus') and self.dialog.doneStatus == 'ok':
                    self.d_requestEnter(base.cr.isPaid())
                else:
                    self.cr.playGame.getPlace().setState('walk')
                self.dialog.ignoreAll()
                self.dialog.cleanup()
                del self.dialog

            self.cr.playGame.getPlace().fsm.request('stopped')
            self.accept('stoppedAsleep', handleEnterRequest)
            doneEvent = 'enterRequest|dialog'
            msg = TTLocalizer.StartingBlock_EnterShowPad
            self.dialog = TTGlobalDialog(msg, doneEvent, 4)
            self.dialog.accept(doneEvent, handleEnterRequest)
    def rejectEnter(self, errCode):
        self.notify.debugStateCall(self)

        def handleTicketError(self=self):
            self.ignore('stoppedAsleep')
            self.dialog.ignoreAll()
            self.dialog.cleanup()
            del self.dialog
            self.cr.playGame.getPlace().setState('walk')

        doneEvent = 'errorCode|dialog'
        if errCode == KartGlobals.ERROR_CODE.eTickets:
            msg = TTLocalizer.StartingBlock_NotEnoughTickets
            self.dialog = TTGlobalDialog(msg, doneEvent, 2)
            self.dialog.accept(doneEvent, handleTicketError)
            self.accept('stoppedAsleep', handleTicketError)
        else:
            if errCode == KartGlobals.ERROR_CODE.eBoardOver:
                msg = TTLocalizer.StartingBlock_NoBoard
                self.dialog = TTGlobalDialog(msg, doneEvent, 2)
                self.dialog.accept(doneEvent, handleTicketError)
                self.accept('stoppedAsleep', handleTicketError)
            else:
                if errCode == KartGlobals.ERROR_CODE.eNoKart:
                    msg = TTLocalizer.StartingBlock_NoKart
                    self.dialog = TTGlobalDialog(msg, doneEvent, 2)
                    self.dialog.accept(doneEvent, handleTicketError)
                    self.accept('stoppedAsleep', handleTicketError)
                else:
                    if errCode == KartGlobals.ERROR_CODE.eOccupied:
                        msg = TTLocalizer.StartingBlock_Occupied
                        self.dialog = TTGlobalDialog(msg, doneEvent, 2)
                        self.dialog.accept(doneEvent, handleTicketError)
                        self.accept('stoppedAsleep', handleTicketError)
                    else:
                        if errCode == KartGlobals.ERROR_CODE.eTrackClosed:
                            msg = TTLocalizer.StartingBlock_TrackClosed
                            self.dialog = TTGlobalDialog(msg, doneEvent, 2)
                            self.dialog.accept(doneEvent, handleTicketError)
                            self.accept('stoppedAsleep', handleTicketError)
                        else:
                            if errCode == KartGlobals.ERROR_CODE.eUnpaid:
                                self.dialog = TeaserPanel(
                                    pageName='karting',
                                    doneFunc=handleTicketError)
                            else:
                                self.cr.playGame.getPlace().setState('walk')
Esempio n. 5
0
    def __handleEnterSphere(self, collEntry):
        """
        comment
        """
        assert self.notify.debug("__handleEnterSphere")

        # Protect against the same toon from re-entering the sphere
        # immediately after exiting. It is most likely a mistake on the
        # toon's part.
        if( base.localAvatar.doId == self.lastAvId and \
            globalClock.getFrameCount() <= self.lastFrame + 1 ):
            self.notify.debug("Ignoring duplicate entry for avatar.")
            return

        # Only toons with hp > 0 and own a kart may enter the sphere.
        if ((base.localAvatar.hp > 0)):

            def handleEnterRequest(self=self):
                self.ignore("stoppedAsleep")
                if hasattr(self.dialog,
                           'doneStatus') and (self.dialog.doneStatus == 'ok'):
                    self.d_requestEnter(base.cr.isPaid())
                else:
                    if self.cr and not self.isDisabled():
                        self.cr.playGame.getPlace().setState("walk")
                    else:
                        self.notify.warning(
                            "Warning! Object has already been disabled.")

                self.dialog.ignoreAll()
                self.dialog.cleanup()
                del self.dialog

            # take the localToon out of walk mode
            self.cr.playGame.getPlace().fsm.request('stopped')

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

            # A dialog box should prompt the toon for action, to either
            # enter a race or ignore it.
            doneEvent = 'enterRequest|dialog'
            if (self.kartPad.isPractice()):
                msg = TTLocalizer.StartingBlock_EnterPractice
            else:
                raceName = TTLocalizer.KartRace_RaceNames[
                    self.kartPad.trackType]
                numTickets = RaceGlobals.getEntryFee(self.kartPad.trackId,
                                                     self.kartPad.trackType)
                msg = TTLocalizer.StartingBlock_EnterNonPractice % (raceName,
                                                                    numTickets)

            self.dialog = TTGlobalDialog(msg, doneEvent, 4)
            self.dialog.accept(doneEvent, handleEnterRequest)
    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. 7
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)