Example #1
0
 def __init__(self, makeAToon, doneEvent, avList, index, isPaid):
     StateData.StateData.__init__(self, doneEvent)
     self.makeAToon = makeAToon
     self.isPaid = isPaid
     self.avList = avList
     self.index = index
     self.shopsVisited = []
     self.avId = -1
     self.avExists = 0
     self.names = ['',
      '',
      '',
      '']
     self.toon = None
     self.boy = 0
     self.girl = 0
     self.allTitles = []
     self.allFirsts = []
     self.allPrefixes = []
     self.allSuffixes = []
     self.titleIndex = 0
     self.firstIndex = 0
     self.prefixIndex = 0
     self.suffixIndex = 0
     self.titleActive = 0
     self.firstActive = 0
     self.lastActive = 0
     self.quickFind = 0
     self.listsLoaded = 0
     self.addedGenderSpecific = 0
     self.chastise = 0
     self.nameIndices = [-1,
      -1,
      -1,
      -1]
     self.nameFlags = [1,
      1,
      1,
      0]
     self.dummyReturn = 2
     self.nameAction = 0
     self.pickANameGUIElements = []
     self.typeANameGUIElements = []
     self.textRolloverColor = Vec4(1, 1, 0, 1)
     self.textDownColor = Vec4(0.5, 0.9, 1, 1)
     self.textDisabledColor = Vec4(0.4, 0.8, 0.4, 1)
     self.fsm = ClassicFSM.ClassicFSM('NameShop', [State.State('Init', self.enterInit, self.exitInit, ['PayState']),
      State.State('PayState', self.enterPayState, self.exitPayState, ['PickAName']),
      State.State('PickAName', self.enterPickANameState, self.exitPickANameState, ['TypeAName', 'Done']),
      State.State('TypeAName', self.enterTypeANameState, self.exitTypeANameState, ['PickAName',
       'Approval',
       'Accepted',
       'Rejected']),
      State.State('Approval', self.enterApprovalState, self.exitApprovalState, ['PickAName', 'ApprovalAccepted']),
      State.State('ApprovalAccepted', self.enterApprovalAcceptedState, self.exitApprovalAcceptedState, ['Done']),
      State.State('Accepted', self.enterAcceptedState, self.exitAcceptedState, ['Done']),
      State.State('Rejected', self.enterRejectedState, self.exitRejectedState, ['TypeAName']),
      State.State('Done', self.enterDone, self.exitDone, ['Init'])], 'Init', 'Done')
     self.parentFSM = makeAToon.fsm
     self.parentFSM.getStateNamed('NameShop').addChild(self.fsm)
     self.nameGen = NameGenerator.NameGenerator()
     self.fsm.enterInitialState()
     self.requestingSkipTutorial = False
     return
 def __init__(self, air, blockNumber, zoneId, trophyMgr):
     DistributedObjectAI.DistributedObjectAI.__init__(self, air)
     self.block = blockNumber
     self.zoneId = zoneId
     self.canonicalZoneId = ZoneUtil.getCanonicalZoneId(zoneId)
     self.trophyMgr = trophyMgr
     self.victorResponses = None
     self.fsm = ClassicFSM.ClassicFSM('DistributedBuildingAI', [
         State.State('off', self.enterOff, self.exitOff, [
             'waitForVictors', 'becomingToon', 'toon',
             'clearOutToonInterior', 'becomingSuit', 'suit',
             'clearOutToonInteriorForCogdo', 'becomingCogdo', 'cogdo'
         ]),
         State.State('waitForVictors', self.enterWaitForVictors,
                     self.exitWaitForVictors, ['becomingToon']),
         State.State(
             'waitForVictorsFromCogdo', self.enterWaitForVictorsFromCogdo,
             self.exitWaitForVictorsFromCogdo, ['becomingToonFromCogdo']),
         State.State('becomingToon', self.enterBecomingToon,
                     self.exitBecomingToon, ['toon']),
         State.State('becomingToonFromCogdo',
                     self.enterBecomingToonFromCogdo,
                     self.exitBecomingToonFromCogdo, ['toon']),
         State.State(
             'toon',
             self.enterToon, self.exitToon,
             ['clearOutToonInterior', 'clearOutToonInteriorForCogdo']),
         State.State('clearOutToonInterior', self.enterClearOutToonInterior,
                     self.exitClearOutToonInterior, ['becomingSuit']),
         State.State('becomingSuit', self.enterBecomingSuit,
                     self.exitBecomingSuit, ['suit']),
         State.State('suit', self.enterSuit, self.exitSuit,
                     ['waitForVictors', 'becomingToon']),
         State.State('clearOutToonInteriorForCogdo',
                     self.enterClearOutToonInteriorForCogdo,
                     self.exitClearOutToonInteriorForCogdo,
                     ['becomingCogdo']),
         State.State('becomingCogdo', self.enterBecomingCogdo,
                     self.exitBecomingCogdo, ['cogdo']),
         State.State('cogdo', self.enterCogdo, self.exitCogdo,
                     ['waitForVictorsFromCogdo', 'becomingToonFromCogdo'])
     ], 'off', 'off')
     self.fsm.enterInitialState()
     self.track = 'c'
     self.difficulty = 1
     self.numFloors = 0
     self.savedBy = None
     self.becameSuitTime = 0
     self.frontDoorPoint = None
     self.suitPlannerExt = None
     return
Example #3
0
 def load(self):
     self.fsm = ClassicFSM.ClassicFSM('FactoryInterior', [
         State.State('start', self.enterStart, self.exitStart,
                     ['walk', 'teleportIn', 'fallDown']),
         State.State('walk', self.enterWalk, self.exitWalk, [
             'push', 'sit', 'stickerBook', 'WaitForBattle', 'battle',
             'died', 'teleportOut', 'squished', 'DFA', 'fallDown',
             'elevator'
         ]),
         State.State('stopped', self.enterStopped, self.exitStopped,
                     ['walk', 'teleportOut']),
         State.State('sit', self.enterSit, self.exitSit,
                     ['walk', 'died', 'teleportOut']),
         State.State('push', self.enterPush, self.exitPush,
                     ['walk', 'died', 'teleportOut']),
         State.State('stickerBook', self.enterStickerBook,
                     self.exitStickerBook, [
                         'walk', 'battle', 'DFA', 'WaitForBattle', 'died',
                         'teleportOut'
                     ]),
         State.State('WaitForBattle', self.enterWaitForBattle,
                     self.exitWaitForBattle,
                     ['battle', 'walk', 'died', 'teleportOut']),
         State.State('battle', self.enterBattle, self.exitBattle,
                     ['walk', 'teleportOut', 'died']),
         State.State('fallDown', self.enterFallDown, self.exitFallDown,
                     ['walk', 'died', 'teleportOut']),
         State.State('squished', self.enterSquished, self.exitSquished,
                     ['walk', 'died', 'teleportOut']),
         State.State('teleportIn', self.enterTeleportIn,
                     self.exitTeleportIn,
                     ['walk', 'teleportOut', 'quietZone', 'died']),
         State.State('teleportOut', self.enterTeleportOut,
                     self.exitTeleportOut,
                     ['teleportIn', 'FLA', 'quietZone', 'WaitForBattle']),
         State.State('DFA', self.enterDFA, self.exitDFA,
                     ['DFAReject', 'teleportOut']),
         State.State('DFAReject', self.enterDFAReject, self.exitDFAReject,
                     ['walkteleportOut']),
         State.State('died', self.enterDied, self.exitDied,
                     ['teleportOut']),
         State.State('FLA', self.enterFLA, self.exitFLA, ['quietZone']),
         State.State('quietZone', self.enterQuietZone, self.exitQuietZone,
                     ['teleportIn']),
         State.State('elevator', self.enterElevator, self.exitElevator,
                     ['walk']),
         State.State('final', self.enterFinal, self.exitFinal, ['start'])
     ], 'start', 'final')
     self.parentFSM.getStateNamed('factoryInterior').addChild(self.fsm)
     BattlePlace.BattlePlace.load(self)
     self.music = base.loader.loadMusic('phase_9/audio/bgm/CHQ_FACT_bg.ogg')
 def __init__(self, cr):
     DistributedToonInterior.__init__(self, cr)
     self.sillyFSM = ClassicFSM.ClassicFSM('SillyOMeter', [
         State.State('Setup', self.enterSetup, self.exitSetup, [
             'Phase0', 'Phase1', 'Phase2', 'Phase3', 'Phase4', 'Phase5',
             'Phase6', 'Phase7', 'Phase8', 'Phase9', 'Phase10', 'Phase11',
             'Phase12', 'Phase13', 'Phase14', 'Phase15', 'Flat', 'Off'
         ]),
         State.State('Phase0', self.enterPhase0, self.exitPhase0, [
             'Phase1', 'Phase2', 'Phase3', 'Phase4', 'Phase5', 'Phase6',
             'Phase7', 'Phase8', 'Phase9', 'Phase10', 'Phase11', 'Phase12',
             'Phase13', 'Phase14', 'Phase15', 'Flat', 'Off'
         ]),
         State.State('Phase1', self.enterPhase1, self.exitPhase1,
                     ['Phase2', 'Flat', 'Off']),
         State.State('Phase2', self.enterPhase2, self.exitPhase2,
                     ['Phase3', 'Flat', 'Off']),
         State.State('Phase3', self.enterPhase3, self.exitPhase3,
                     ['Phase4', 'Flat', 'Off']),
         State.State('Phase4', self.enterPhase4, self.exitPhase4,
                     ['Phase5', 'Flat', 'Off']),
         State.State('Phase5', self.enterPhase5, self.exitPhase5,
                     ['Phase6', 'Flat', 'Off']),
         State.State('Phase6', self.enterPhase6, self.exitPhase6,
                     ['Phase7', 'Flat', 'Off']),
         State.State('Phase7', self.enterPhase7, self.exitPhase7,
                     ['Phase8', 'Flat', 'Off']),
         State.State('Phase8', self.enterPhase8, self.exitPhase8,
                     ['Phase9', 'Flat', 'Off']),
         State.State('Phase9', self.enterPhase9, self.exitPhase9,
                     ['Phase10', 'Flat', 'Off']),
         State.State('Phase10', self.enterPhase10, self.exitPhase10,
                     ['Phase11', 'Flat', 'Off']),
         State.State('Phase11', self.enterPhase11, self.exitPhase11,
                     ['Phase12', 'Flat', 'Off']),
         State.State('Phase12', self.enterPhase12, self.exitPhase12,
                     ['Phase13', 'Flat', 'Off']),
         State.State('Phase13', self.enterPhase13, self.exitPhase13,
                     ['Phase14', 'Flat', 'Off']),
         State.State('Phase14', self.enterPhase14, self.exitPhase14,
                     ['Phase15', 'Flat', 'Off']),
         State.State('Phase15', self.enterPhase15, self.exitPhase15,
                     ['Flat', 'Off']),
         State.State('Flat', self.enterFlat, self.exitFlat,
                     ['Off', 'Phase0']),
         State.State('Off', self.enterOff, self.exitOff, [])
     ], 'Setup', 'Off')
     self.phaseDuration = -1
     self.curPhase = -1
Example #5
0
    def __init__(self, parentFSM, doneEvent):
        """__init__(self, ClassicFSM, string)
        PlayGame constructor: create a play game ClassicFSM
        """
        StateData.StateData.__init__(self, doneEvent)
        self.place = None
        self.fsm = ClassicFSM.ClassicFSM(
            'PlayGame',
            [
                State.State('start', self.enterStart, self.exitStart,
                            ['quietZone']),
                State.State(
                    'quietZone', self.enterQuietZone, self.exitQuietZone, [
                        'TTHood', 'DDHood', 'BRHood', 'MMHood', 'DGHood',
                        'DLHood', 'GSHood', 'OZHood', 'GZHood', 'SellbotHQ',
                        'CashbotHQ', 'LawbotHQ', 'BossbotHQ', 'TutorialHood',
                        'EstateHood', 'PartyHood'
                    ]),
                State.State('TTHood', self.enterTTHood, self.exitTTHood,
                            ['quietZone']),
                State.State('DDHood', self.enterDDHood, self.exitDDHood,
                            ['quietZone']),
                State.State('BRHood', self.enterBRHood, self.exitBRHood,
                            ['quietZone']),
                State.State('MMHood', self.enterMMHood, self.exitMMHood,
                            ['quietZone']),
                State.State('DGHood', self.enterDGHood, self.exitDGHood,
                            ['quietZone']),
                State.State('DLHood', self.enterDLHood, self.exitDLHood,
                            ['quietZone']),
                State.State('GSHood', self.enterGSHood, self.exitGSHood,
                            ['quietZone']),
                State.State('OZHood', self.enterOZHood, self.exitOZHood,
                            ['quietZone']),
                State.State('GZHood', self.enterGZHood, self.exitGZHood,
                            ['quietZone']),
                State.State('BossbotHQ', self.enterBossbotHQ,
                            self.exitBossbotHQ, ['quietZone']),
                State.State('SellbotHQ', self.enterSellbotHQ,
                            self.exitSellbotHQ, ['quietZone']),
                State.State('CashbotHQ', self.enterCashbotHQ,
                            self.exitCashbotHQ, ['quietZone']),
                State.State('LawbotHQ', self.enterLawbotHQ, self.exitLawbotHQ,
                            ['quietZone']),
                State.State('TutorialHood', self.enterTutorialHood,
                            self.exitTutorialHood, ['quietZone']),
                State.State('EstateHood', self.enterEstateHood,
                            self.exitEstateHood, ['quietZone']),
                State.State('PartyHood', self.enterPartyHood,
                            self.exitPartyHood, ['quietZone']),
            ],
            # Initial State
            'start',
            # Final State
            'start',
        )

        self.fsm.enterInitialState()

        self.parentFSM = parentFSM
        # Add this state machine to the parent fsm playGame state
        self.parentFSM.getStateNamed("playGame").addChild(self.fsm)
        # Create the state datas for each hood
        self.hoodDoneEvent = "hoodDone"
        self.hood = None
Example #6
0
    def __init__(self, avId, avName, avDisableName):
        self.wantPlayerFriends = base.config.GetBool('want-player-friends', 0)
        DirectFrame.__init__(self,
                             pos=(0.29999999999999999, 0.10000000000000001,
                                  0.65000000000000002),
                             image_color=GlobalDialogColor,
                             image_scale=(1.0, 1.0, 0.59999999999999998),
                             text='',
                             text_wordwrap=TTLocalizer.FIdirectFrameWordwrap,
                             text_scale=TTLocalizer.FIdirectFrame,
                             text_pos=TTLocalizer.FIdirectFramePos)
        self['image'] = DGG.getDefaultDialogGeom()
        self.avId = avId
        self.toonName = avName
        avatar = base.cr.doId2do.get(self.avId)
        self.playerId = None
        self.playerName = None
        if avatar:
            self.playerId = avatar.DISLid
            self.playerName = avatar.DISLname + ' ' + str(avatar.DISLid)

        self.avDisableName = avDisableName
        self.playerFriend = 0
        self.fsm = ClassicFSM.ClassicFSM('FriendInviter', [
            State.State('off', self.enterOff, self.exitOff),
            State.State('getNewFriend', self.enterGetNewFriend,
                        self.exitGetNewFriend),
            State.State('begin', self.enterBegin, self.exitBegin),
            State.State('check', self.enterCheck, self.exitCheck),
            State.State('tooMany', self.enterTooMany, self.exitTooMany),
            State.State('checkAvailability', self.enterCheckAvailability,
                        self.exitCheckAvailability),
            State.State('notAvailable', self.enterNotAvailable,
                        self.exitNotAvailable),
            State.State('notAcceptingFriends', self.enterNotAcceptingFriends,
                        self.exitNotAcceptingFriends),
            State.State('wentAway', self.enterWentAway, self.exitWentAway),
            State.State('already', self.enterAlready, self.exitAlready),
            State.State('askingCog', self.enterAskingCog, self.exitAskingCog),
            State.State('askingPet', self.enterAskingPet, self.exitAskingPet),
            State.State('endFriendship', self.enterEndFriendship,
                        self.exitEndFriendship),
            State.State('friendsNoMore', self.enterFriendsNoMore,
                        self.exitFriendsNoMore),
            State.State('self', self.enterSelf, self.exitSelf),
            State.State('ignored', self.enterIgnored, self.exitIgnored),
            State.State('asking', self.enterAsking, self.exitAsking),
            State.State('yes', self.enterYes, self.exitYes),
            State.State('no', self.enterNo, self.exitNo),
            State.State('otherTooMany', self.enterOtherTooMany,
                        self.exitOtherTooMany),
            State.State('maybe', self.enterMaybe, self.exitMaybe),
            State.State('down', self.enterDown, self.exitDown),
            State.State('cancel', self.enterCancel, self.exitCancel)
        ], 'off', 'off')
        self.context = None
        ToonAvatarDetailPanel = ToonAvatarDetailPanel
        import toontown.toon
        ToonTeleportPanel.hideTeleportPanel()
        ToonAvatarDetailPanel.hideAvatarDetail()
        buttons = loader.loadModel('phase_3/models/gui/dialog_box_buttons_gui')
        gui = loader.loadModel('phase_3.5/models/gui/avatar_panel_gui')
        self.bOk = DirectButton(self,
                                image=(buttons.find('**/ChtBx_OKBtn_UP'),
                                       buttons.find('**/ChtBx_OKBtn_DN'),
                                       buttons.find('**/ChtBx_OKBtn_Rllvr')),
                                relief=None,
                                text=OTPLocalizer.FriendInviterOK,
                                text_scale=0.050000000000000003,
                                text_pos=(0.0, -0.10000000000000001),
                                pos=(0.0, 0.0, -0.10000000000000001),
                                command=self._FriendInviter__handleOk)
        self.bOk.hide()
        self.bCancel = DirectButton(self,
                                    image=(buttons.find('**/CloseBtn_UP'),
                                           buttons.find('**/CloseBtn_DN'),
                                           buttons.find('**/CloseBtn_Rllvr')),
                                    relief=None,
                                    text=OTPLocalizer.FriendInviterCancel,
                                    text_scale=0.050000000000000003,
                                    text_pos=(0.0, -0.10000000000000001),
                                    pos=TTLocalizer.FIbCancelPos,
                                    command=self._FriendInviter__handleCancel)
        self.bCancel.hide()
        self.bStop = DirectButton(
            self,
            image=(gui.find('**/Ignore_Btn_UP'), gui.find('**/Ignore_Btn_DN'),
                   gui.find('**/Ignore_Btn_RLVR')),
            relief=None,
            text=OTPLocalizer.FriendInviterStopBeingFriends,
            text_align=TextNode.ALeft,
            text_scale=TTLocalizer.FIbStop,
            text_pos=TTLocalizer.FIbStopTextPos,
            pos=TTLocalizer.FIbStopPos,
            command=self._FriendInviter__handleStop)
        self.bStop.hide()
        self.bYes = DirectButton(self,
                                 image=(buttons.find('**/ChtBx_OKBtn_UP'),
                                        buttons.find('**/ChtBx_OKBtn_DN'),
                                        buttons.find('**/ChtBx_OKBtn_Rllvr')),
                                 relief=None,
                                 text=OTPLocalizer.FriendInviterYes,
                                 text_scale=0.050000000000000003,
                                 text_pos=(0.0, -0.10000000000000001),
                                 pos=TTLocalizer.FIbYesPos,
                                 command=self._FriendInviter__handleYes)
        self.bYes.hide()
        self.bNo = DirectButton(self,
                                image=(buttons.find('**/CloseBtn_UP'),
                                       buttons.find('**/CloseBtn_DN'),
                                       buttons.find('**/CloseBtn_Rllvr')),
                                relief=None,
                                text=OTPLocalizer.FriendInviterNo,
                                text_scale=0.050000000000000003,
                                text_pos=(0.0, -0.10000000000000001),
                                pos=(0.14999999999999999, 0.0,
                                     -0.10000000000000001),
                                command=self._FriendInviter__handleNo)
        self.bNo.hide()
        self.bToon = DirectButton(self,
                                  image=(buttons.find('**/ChtBx_OKBtn_UP'),
                                         buttons.find('**/ChtBx_OKBtn_DN'),
                                         buttons.find('**/ChtBx_OKBtn_Rllvr')),
                                  relief=None,
                                  text=TTLocalizer.FriendInviterToon,
                                  text_scale=0.050000000000000003,
                                  text_pos=(0.0, -0.10000000000000001),
                                  pos=(-0.34999999999999998, 0.0,
                                       -0.050000000000000003),
                                  command=self._FriendInviter__handleToon)
        toonText = DirectLabel(parent=self,
                               relief=None,
                               pos=Vec3(0.34999999999999998, 0,
                                        -0.20000000000000001),
                               text=TTLocalizer.FriendInviterToonFriendInfo,
                               text_fg=(0, 0, 0, 1),
                               text_pos=(0, 0),
                               text_scale=0.044999999999999998,
                               text_align=TextNode.ACenter)
        toonText.reparentTo(self.bToon.stateNodePath[2])
        self.bToon.hide()
        self.bPlayer = DirectButton(
            self,
            image=(buttons.find('**/ChtBx_OKBtn_UP'),
                   buttons.find('**/ChtBx_OKBtn_DN'),
                   buttons.find('**/ChtBx_OKBtn_Rllvr')),
            relief=None,
            text=TTLocalizer.FriendInviterPlayer,
            text_scale=0.050000000000000003,
            text_pos=(0.0, -0.10000000000000001),
            pos=(0.0, 0.0, -0.050000000000000003),
            command=self._FriendInviter__handlePlayer)
        playerText = DirectLabel(
            parent=self,
            relief=None,
            pos=Vec3(0, 0, -0.20000000000000001),
            text=TTLocalizer.FriendInviterPlayerFriendInfo,
            text_fg=(0, 0, 0, 1),
            text_pos=(0, 0),
            text_scale=0.044999999999999998,
            text_align=TextNode.ACenter)
        playerText.reparentTo(self.bPlayer.stateNodePath[2])
        self.bPlayer.hide()
        buttons.removeNode()
        gui.removeNode()
        self.fsm.enterInitialState()
        if self.avId == None:
            self.fsm.request('getNewFriend')
        else:
            self.fsm.request('begin')
Example #7
0
 def __init__(self, cr):
     DistributedMinigame.__init__(self, cr)
     self.gameFSM = ClassicFSM.ClassicFSM('DistributedCatchGame', [State.State('off', self.enterOff, self.exitOff, ['play']), State.State('play', self.enterPlay, self.exitPlay, ['cleanup']), State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup')
     self.addChildGameFSM(self.gameFSM)
     self.setUsesSmoothing()
     self.setUsesLookAround()
Example #8
0
 def __init__(self, loader, parentFSM, doneEvent):
     BattlePlace.BattlePlace.__init__(self, loader, doneEvent)
     self.parentFSM = parentFSM
     self.elevatorDoneEvent = 'elevatorDone'
     self.fsm = ClassicFSM.ClassicFSM('FactoryExterior', [
         State.State(
             'start', self.enterStart, self.exitStart,
             ['walk', 'tunnelIn', 'teleportIn', 'doorIn', 'trainIn']),
         State.State('walk', self.enterWalk, self.exitWalk, [
             'stickerBook', 'teleportOut', 'tunnelOut', 'DFA', 'doorOut',
             'elevator', 'stopped', 'WaitForBattle', 'battle'
         ]),
         State.State('stopped', self.enterStopped, self.exitStopped,
                     ['walk', 'teleportOut', 'elevator']),
         State.State(
             'stickerBook', self.enterStickerBook, self.exitStickerBook,
             ['walk', 'DFA', 'WaitForBattle', 'battle', 'elevator']),
         State.State('WaitForBattle', self.enterWaitForBattle,
                     self.exitWaitForBattle, ['battle', 'walk']),
         State.State('battle', self.enterBattle, self.exitBattle,
                     ['walk', 'teleportOut', 'died']),
         State.State('DFA', self.enterDFA, self.exitDFA,
                     ['DFAReject', 'teleportOut', 'tunnelOut']),
         State.State('DFAReject', self.enterDFAReject, self.exitDFAReject,
                     ['walk']),
         State.State('teleportIn', self.enterTeleportIn,
                     self.exitTeleportIn, ['walk']),
         State.State('teleportOut', self.enterTeleportOut,
                     self.exitTeleportOut,
                     ['teleportIn', 'final', 'WaitForBattle']),
         State.State('doorIn', self.enterDoorIn, self.exitDoorIn, ['walk']),
         State.State('doorOut', self.enterDoorOut, self.exitDoorOut,
                     ['walk']),
         State.State('died', self.enterDied, self.exitDied, ['quietZone']),
         State.State('tunnelIn', self.enterTunnelIn, self.exitTunnelIn,
                     ['walk']),
         State.State('tunnelOut', self.enterTunnelOut, self.exitTunnelOut,
                     ['final']),
         State.State('trainIn', self.enterTrainIn, self.exitTrainIn,
                     ['teleportIn', 'walk', 'WaitForBattle', 'battle']),
         State.State('elevator', self.enterElevator, self.exitElevator,
                     ['walk', 'stopped']),
         State.State('final', self.enterFinal, self.exitFinal, ['start'])
     ], 'start', 'final')
 def __init__(self, cr):
     DistributedObject.DistributedObject.__init__(self, cr)
     self.avId = 0
     self.av = None
     self.localToonShooting = 0
     self.nodePath = None
     self.collSphere = None
     self.collNode = None
     self.collNodePath = None
     self.madeGui = 0
     self.gui = None
     self.cannonLocation = None
     self.cannonPosition = None
     self.cannon = None
     self.toonModel = None
     self.shadowNode = None
     self.toonHead = None
     self.toonScale = None
     self.estateId = None
     self.targetId = None
     self.splash = None
     self.dustCloud = None
     self.model_Created = 0
     self.lastWakeTime = 0
     self.leftPressed = 0
     self.rightPressed = 0
     self.upPressed = 0
     self.downPressed = 0
     self.hitBumper = 0
     self.hitTarget = 0
     self.lastPos = Vec3(0, 0, 0)
     self.lastVel = Vec3(0, 0, 0)
     self.vel = Vec3(0, 0, 0)
     self.landingPos = Vec3(0, 0, 0)
     self.t = 0
     self.lastT = 0
     self.deltaT = 0
     self.hitTrack = None
     self.cTrav = None
     self.cRay = None
     self.cRayNode = None
     self.cRayNodePath = None
     self.lifter = None
     self.flyColNode = None
     self.flyColNodePath = None
     self.bumperCol = None
     self.cannonMoving = 0
     self.inWater = 0
     self.localAvId = base.localAvatar.doId
     self.nextState = None
     self.nextKey = None
     self.cannonsActive = 0
     self.codeFSM = ClassicFSM.ClassicFSM('CannonCode', [
         State.State('init', self.enterInit, self.exitInit, [
             'u1',
             'init']),
         State.State('u1', self.enteru1, self.exitu1, [
             'u2',
             'init']),
         State.State('u2', self.enteru2, self.exitu2, [
             'd3',
             'init']),
         State.State('d3', self.enterd3, self.exitd3, [
             'd4',
             'init']),
         State.State('d4', self.enterd4, self.exitd4, [
             'l5',
             'init']),
         State.State('l5', self.enterl5, self.exitl5, [
             'r6',
             'init']),
         State.State('r6', self.enterr6, self.exitr6, [
             'l7',
             'init']),
         State.State('l7', self.enterl7, self.exitl7, [
             'r8',
             'init']),
         State.State('r8', self.enterr8, self.exitr8, [
             'acceptCode',
             'init']),
         State.State('acceptCode', self.enterAcceptCode, self.exitAcceptCode, [
             'init',
             'final']),
         State.State('final', self.enterFinal, self.exitFinal, [])], 'init', 'final')
     self.codeFSM.enterInitialState()
     self.curPinballScore = 0
     self.curPinballMultiplier = 1
Example #10
0
 def __init__(self, parentFSM, doneEvent):
     StateData.StateData.__init__(self, doneEvent)
     self.place = None
     self.fsm = ClassicFSM.ClassicFSM('PlayGame', [
         State.State('start', self.enterStart, self.exitStart,
                     ['quietZone']),
         State.State('quietZone', self.enterQuietZone, self.exitQuietZone, [
             'TTHood', 'TTOHood', 'DDHood', 'BRHood', 'MMHood', 'DGHood',
             'DLHood', 'GSHood', 'OZHood', 'GZHood', 'SellbotHQ',
             'CashbotHQ', 'LawbotHQ', 'BossbotHQ', 'TutorialHood',
             'EstateHood', 'PartyHood', 'BoardbotHQ'
         ]),
         State.State('TTHood', self.enterTTHood, self.exitTTHood,
                     ['quietZone']),
         State.State('TTOHood', self.enterTTOHood, self.exitTTOHood,
                     ['quietZone']),
         State.State('DDHood', self.enterDDHood, self.exitDDHood,
                     ['quietZone']),
         State.State('BRHood', self.enterBRHood, self.exitBRHood,
                     ['quietZone']),
         State.State('MMHood', self.enterMMHood, self.exitMMHood,
                     ['quietZone']),
         State.State('DGHood', self.enterDGHood, self.exitDGHood,
                     ['quietZone']),
         State.State('DLHood', self.enterDLHood, self.exitDLHood,
                     ['quietZone']),
         State.State('GSHood', self.enterGSHood, self.exitGSHood,
                     ['quietZone']),
         State.State('OZHood', self.enterOZHood, self.exitOZHood,
                     ['quietZone']),
         State.State('GZHood', self.enterGZHood, self.exitGZHood,
                     ['quietZone']),
         State.State('BossbotHQ', self.enterBossbotHQ, self.exitBossbotHQ,
                     ['quietZone']),
         State.State('SellbotHQ', self.enterSellbotHQ, self.exitSellbotHQ,
                     ['quietZone']),
         State.State('CashbotHQ', self.enterCashbotHQ, self.exitCashbotHQ,
                     ['quietZone']),
         State.State('LawbotHQ', self.enterLawbotHQ, self.exitLawbotHQ,
                     ['quietZone']),
         State.State('TutorialHood', self.enterTutorialHood,
                     self.exitTutorialHood, ['quietZone']),
         State.State('EstateHood', self.enterEstateHood,
                     self.exitEstateHood, ['quietZone']),
         State.State('PartyHood', self.enterPartyHood, self.exitPartyHood,
                     ['quietZone']),
         State.State('BoardbotHQ', self.enterBoardbotHQ,
                     self.exitBoardbotHQ, ['quietZone'])
     ], 'start', 'start')
     self.fsm.enterInitialState()
     self.parentFSM = parentFSM
     self.parentFSM.getStateNamed('playGame').addChild(self.fsm)
     self.hoodDoneEvent = 'hoodDone'
     self.hood = None
     self.quietZoneDoneEvent = uniqueName('quietZoneDone')
     self.quietZoneStateData = None
Example #11
0
 def __init__(self, cr, localAvatar):
     self.cr = cr
     self.localAvatar = localAvatar
     self.wantBackgroundFocus = 1
     self.__scObscured = 0
     self.__normalObscured = 0
     self.openChatWarning = None
     self.unpaidChatWarning = None
     self.teaser = None
     self.paidNoParentPassword = None
     self.noSecretChatAtAll = None
     self.noSecretChatAtAllAndNoWhitelist = None
     self.noSecretChatWarning = None
     self.activateChatGui = None
     self.chatMoreInfo = None
     self.chatPrivacyPolicy = None
     self.secretChatActivated = None
     self.problemActivatingChat = None
     self.leaveToPayDialog = None
     self.fsm = ClassicFSM.ClassicFSM('chatManager', [State.State('off', self.enterOff, self.exitOff),
      State.State('mainMenu', self.enterMainMenu, self.exitMainMenu),
      State.State('speedChat', self.enterSpeedChat, self.exitSpeedChat),
      State.State('normalChat', self.enterNormalChat, self.exitNormalChat),
      State.State('whisper', self.enterWhisper, self.exitWhisper),
      State.State('whisperChat', self.enterWhisperChat, self.exitWhisperChat),
      State.State('whisperChatPlayer', self.enterWhisperChatPlayer, self.exitWhisperChatPlayer),
      State.State('whisperSpeedChat', self.enterWhisperSpeedChat, self.exitWhisperSpeedChat),
      State.State('whisperSpeedChatPlayer', self.enterWhisperSpeedChatPlayer, self.exitWhisperSpeedChatPlayer),
      State.State('openChatWarning', self.enterOpenChatWarning, self.exitOpenChatWarning),
      State.State('leaveToPayDialog', self.enterLeaveToPayDialog, self.exitLeaveToPayDialog),
      State.State('unpaidChatWarning', self.enterUnpaidChatWarning, self.exitUnpaidChatWarning),
      State.State('noSecretChatAtAll', self.enterNoSecretChatAtAll, self.exitNoSecretChatAtAll),
      State.State('noSecretChatAtAllAndNoWhitelist', self.enterNoSecretChatAtAllAndNoWhitelist, self.exitNoSecretChatAtAllAndNoWhitelist),
      State.State('noSecretChatWarning', self.enterNoSecretChatWarning, self.exitNoSecretChatWarning),
      State.State('noFriendsWarning', self.enterNoFriendsWarning, self.exitNoFriendsWarning),
      State.State('otherDialog', self.enterOtherDialog, self.exitOtherDialog),
      State.State('activateChat', self.enterActivateChat, self.exitActivateChat),
      State.State('chatMoreInfo', self.enterChatMoreInfo, self.exitChatMoreInfo),
      State.State('chatPrivacyPolicy', self.enterChatPrivacyPolicy, self.exitChatPrivacyPolicy),
      State.State('secretChatActivated', self.enterSecretChatActivated, self.exitSecretChatActivated),
      State.State('problemActivatingChat', self.enterProblemActivatingChat, self.exitProblemActivatingChat),
      State.State('whiteListOpenChat', self.enterWhiteListOpenChat, self.exitWhiteListOpenChat),
      State.State('whiteListAvatarChat', self.enterWhiteListAvatarChat, self.exitWhiteListAvatarChat),
      State.State('whiteListPlayerChat', self.enterWhiteListPlayerChat, self.exitWhiteListPlayerChat),
      State.State('trueFriendTeaserPanel', self.enterTrueFriendTeaserPanel, self.exitTrueFriendTeaserPanel)], 'off', 'off')
     self.fsm.enterInitialState()
     return
Example #12
0
 def __init__(self, path = None):
     if path is not None:
         if path in CountryClubRoomSpecs.BossbotCountryClubConnectorRooms:
             loadFunc = loader.loadModelCopy
         else:
             loadFunc = loader.loadModel
         self.setGeom(loadFunc(path))
     self.localToonFSM = ClassicFSM.ClassicFSM('CountryClubRoomLocalToonPresent', [State.State('off', self.enterLtOff, self.exitLtOff, ['notPresent']), State.State('notPresent', self.enterLtNotPresent, self.exitLtNotPresent, ['present']), State.State('present', self.enterLtPresent, self.exitLtPresent, ['notPresent'])], 'notPresent', 'notPresent')
     self.localToonFSM.enterInitialState()
     return
 def __init__(self, loader, parentFSMState, doneEvent):
     Place.Place.__init__(self, loader, doneEvent)
     self.dnaFile = 'phase_7/models/modules/toon_interior'
     self.isInterior = 1
     self.tfaDoneEvent = 'tfaDoneEvent'
     self.hfaDoneEvent = 'hfaDoneEvent'
     self.npcfaDoneEvent = 'npcfaDoneEvent'
     self.fsm = ClassicFSM.ClassicFSM('ToonInterior', [
         State.State('start', self.enterStart, self.exitStart,
                     ['doorIn', 'teleportIn', 'tutorial']),
         State.State('walk', self.enterWalk, self.exitWalk, [
             'sit', 'stickerBook', 'doorOut', 'DFA', 'teleportOut', 'quest',
             'purchase', 'phone', 'stopped', 'pet'
         ]),
         State.State('sit', self.enterSit, self.exitSit, ['walk']),
         State.State(
             'stickerBook', self.enterStickerBook, self.exitStickerBook, [
                 'walk', 'DFA', 'sit', 'doorOut', 'teleportOut', 'quest',
                 'purchase', 'phone', 'stopped', 'pet'
             ]),
         State.State(
             'DFA', self.enterDFA, self.exitDFA,
             ['DFAReject', 'HFA', 'NPCFA', 'teleportOut', 'doorOut']),
         State.State('DFAReject', self.enterDFAReject, self.exitDFAReject,
                     ['walk']),
         State.State('NPCFA', self.enterNPCFA, self.exitNPCFA,
                     ['NPCFAReject', 'HFA', 'teleportOut']),
         State.State('NPCFAReject', self.enterNPCFAReject,
                     self.exitNPCFAReject, ['walk']),
         State.State('HFA', self.enterHFA, self.exitHFA,
                     ['HFAReject', 'teleportOut', 'tunnelOut']),
         State.State('HFAReject', self.enterHFAReject, self.exitHFAReject,
                     ['walk']),
         State.State('doorIn', self.enterDoorIn, self.exitDoorIn, ['walk']),
         State.State('doorOut', self.enterDoorOut, self.exitDoorOut,
                     ['walk']),
         State.State('teleportIn', self.enterTeleportIn,
                     self.exitTeleportIn, ['walk']),
         State.State('teleportOut', self.enterTeleportOut,
                     self.exitTeleportOut, ['teleportIn']),
         State.State('quest', self.enterQuest, self.exitQuest,
                     ['walk', 'doorOut']),
         State.State('tutorial', self.enterTutorial, self.exitTutorial,
                     ['walk', 'quest']),
         State.State('purchase', self.enterPurchase, self.exitPurchase,
                     ['walk', 'doorOut']),
         State.State('pet', self.enterPet, self.exitPet, ['walk']),
         State.State('phone', self.enterPhone, self.exitPhone,
                     ['walk', 'doorOut']),
         State.State('stopped', self.enterStopped, self.exitStopped,
                     ['walk', 'doorOut']),
         State.State('final', self.enterFinal, self.exitFinal, ['start'])
     ], 'start', 'final')
     self.parentFSMState = parentFSMState
 def __init__(self, cr):
     DistributedMinigame.DistributedMinigame.__init__(self, cr)
     DistributedIceWorld.DistributedIceWorld.__init__(self, cr)
     self.gameFSM = ClassicFSM.ClassicFSM('DistributedIceGame', [
         State.State('off', self.enterOff, self.exitOff, ['inputChoice']),
         State.State(
             'inputChoice', self.enterInputChoice, self.exitInputChoice,
             ['waitServerChoices', 'moveTires', 'displayVotes', 'cleanup']),
         State.State('waitServerChoices', self.enterWaitServerChoices,
                     self.exitWaitServerChoices, ['moveTires', 'cleanup']),
         State.State('moveTires', self.enterMoveTires, self.exitMoveTires,
                     ['synch', 'cleanup']),
         State.State('synch', self.enterSynch, self.exitSynch,
                     ['inputChoice', 'scoring', 'cleanup']),
         State.State('scoring', self.enterScoring, self.exitScoring,
                     ['cleanup', 'finalResults', 'inputChoice']),
         State.State('finalResults', self.enterFinalResults,
                     self.exitFinalResults, ['cleanup']),
         State.State('cleanup', self.enterCleanup, self.exitCleanup, [])
     ], 'off', 'cleanup')
     self.addChildGameFSM(self.gameFSM)
     self.cameraThreeQuarterView = (0, -22, 45, 0, -62.89, 0)
     self.tireDict = {}
     self.forceArrowDict = {}
     self.canDrive = False
     self.timer = None
     self.timerStartTime = None
     self.curForce = 0
     self.curHeading = 0
     self.headingMomentum = 0.0
     self.forceMomentum = 0.0
     self.allTireInputs = None
     self.curRound = 0
     self.curMatch = 0
     self.controlKeyWarningLabel = DirectLabel(
         text=TTLocalizer.IceGameControlKeyWarning,
         text_fg=VBase4(1, 0, 0, 1),
         relief=None,
         pos=(0.0, 0, 0),
         scale=0.15)
     self.controlKeyWarningLabel.hide()
     self.waitingMoveLabel = DirectLabel(
         text=TTLocalizer.IceGameWaitingForPlayersToFinishMove,
         text_fg=VBase4(1, 1, 1, 1),
         relief=None,
         pos=(-0.6, 0, -0.75),
         scale=0.075)
     self.waitingMoveLabel.hide()
     self.waitingSyncLabel = DirectLabel(
         text=TTLocalizer.IceGameWaitingForAISync,
         text_fg=VBase4(1, 1, 1, 1),
         relief=None,
         pos=(-0.6, 0, -0.75),
         scale=0.075)
     self.waitingSyncLabel.hide()
     self.infoLabel = DirectLabel(text='',
                                  text_fg=VBase4(0, 0, 0, 1),
                                  relief=None,
                                  pos=(0.0, 0, 0.7),
                                  scale=0.075)
     self.updateInfoLabel()
     self.lastForceArrowUpdateTime = 0
     self.sendForceArrowUpdateAsap = False
     self.treasures = []
     self.penalties = []
     self.obstacles = []
     self.controlKeyPressed = False
     self.controlKeyWarningIval = None
     return
Example #15
0
 def __init__(self, avId, avName, avDisableName):
     DirectFrame.__init__(self, pos=(0.3, 0.1, 0.65), image_color=ToontownGlobals.GlobalDialogColor, image_scale=(1.0, 1.0, 0.6), text='', text_wordwrap=13.5, text_scale=0.06, text_pos=(0.0, 0.18))
     messenger.send('releaseDirector')
     self['image'] = DGG.getDefaultDialogGeom()
     self.avId = avId
     self.avName = avName
     self.avDisableName = avDisableName
     self.fsm = ClassicFSM.ClassicFSM('ToonTeleportPanel', [
         State.State('off',
             self.enterOff,
             self.exitOff),
         State.State('begin',
             self.enterBegin,
             self.exitBegin),
         State.State('checkAvailability',
             self.enterCheckAvailability,
             self.exitCheckAvailability),
         State.State('notAvailable',
             self.enterNotAvailable,
             self.exitNotAvailable),
         State.State('ignored',
             self.enterIgnored,
             self.exitIgnored),
         State.State('notOnline',
             self.enterNotOnline,
             self.exitNotOnline),
         State.State('wentAway',
             self.enterWentAway,
             self.exitWentAway),
         State.State('self',
             self.enterSelf,
             self.exitSelf),
         State.State('unknownHood',
             self.enterUnknownHood,
             self.exitUnknownHood),
         State.State('unavailableHood',
             self.enterUnavailableHood,
             self.exitUnavailableHood),
         State.State('otherShard',
             self.enterOtherShard,
             self.exitOtherShard),
         State.State('teleport',
             self.enterTeleport,
             self.exitTeleport)],
         'off', 'off')
     from toontown.friends import FriendInviter
     FriendInviter.hideFriendInviter()
     ToonAvatarDetailPanel.hideAvatarDetail()
     buttons = loader.loadModel('phase_3/models/gui/dialog_box_buttons_gui')
     self.bOk = DirectButton(self, image=(buttons.find('**/ChtBx_OKBtn_UP'), buttons.find('**/ChtBx_OKBtn_DN'), buttons.find('**/ChtBx_OKBtn_Rllvr')), relief=None, text=TTLocalizer.TeleportPanelOK, text_scale=0.05, text_pos=(0.0, -0.1), pos=(0.0, 0.0, -0.1), command=self.__handleOk)
     self.bOk.hide()
     self.bCancel = DirectButton(self, image=(buttons.find('**/CloseBtn_UP'), buttons.find('**/CloseBtn_DN'), buttons.find('**/CloseBtn_Rllvr')), relief=None, text=TTLocalizer.TeleportPanelCancel, text_scale=0.05, text_pos=(0.0, -0.1), pos=(0.0, 0.0, -0.1), command=self.__handleCancel)
     self.bCancel.hide()
     self.bYes = DirectButton(self, image=(buttons.find('**/ChtBx_OKBtn_UP'), buttons.find('**/ChtBx_OKBtn_DN'), buttons.find('**/ChtBx_OKBtn_Rllvr')), relief=None, text=TTLocalizer.TeleportPanelYes, text_scale=0.05, text_pos=(0.0, -0.1), pos=(-0.15, 0.0, -0.15), command=self.__handleYes)
     self.bYes.hide()
     self.bNo = DirectButton(self, image=(buttons.find('**/CloseBtn_UP'), buttons.find('**/CloseBtn_DN'), buttons.find('**/CloseBtn_Rllvr')), relief=None, text=TTLocalizer.TeleportPanelNo, text_scale=0.05, text_pos=(0.0, -0.1), pos=(0.15, 0.0, -0.15), command=self.__handleNo)
     self.bNo.hide()
     buttons.removeNode()
     self.accept(self.avDisableName, self.__handleDisableAvatar)
     self.show()
     self.fsm.enterInitialState()
     self.fsm.request('begin')
     return
Example #16
0
 def __init__(self, doneEvent):
     StateData.StateData.__init__(self, doneEvent)
     self.numCogs = 1
     self.creditLevel = None
     self.luredIndices = []
     self.trappedIndices = []
     self.numToons = 1
     self.toons = []
     self.localNum = 0
     self.time = 0
     self.bldg = 0
     self.track = -1
     self.level = -1
     self.target = 0
     self.toonAttacks = [(-1, 0, 0), (-1, 0, 0), (-1, 0, 0), (-1, 0, 0)]
     self.fsm = ClassicFSM.ClassicFSM('TownBattle', [
         State.State('Off', self.enterOff, self.exitOff, ['Attack']),
         State.State('Attack', self.enterAttack, self.exitAttack, [
             'ChooseCog', 'ChooseToon', 'AttackWait', 'Run', 'Fire', 'SOS'
         ]),
         State.State('ChooseCog', self.enterChooseCog, self.exitChooseCog,
                     ['AttackWait', 'Attack']),
         State.State('AttackWait', self.enterAttackWait,
                     self.exitAttackWait,
                     ['ChooseCog', 'ChooseToon', 'Attack']),
         State.State('ChooseToon', self.enterChooseToon,
                     self.exitChooseToon, ['AttackWait', 'Attack']),
         State.State('Run', self.enterRun, self.exitRun, ['Attack']),
         State.State(
             'SOS', self.enterSOS, self.exitSOS,
             ['Attack', 'AttackWait', 'SOSPetSearch', 'SOSPetInfo']),
         State.State('SOSPetSearch', self.enterSOSPetSearch,
                     self.exitSOSPetSearch, ['SOS', 'SOSPetInfo']),
         State.State('SOSPetInfo', self.enterSOSPetInfo,
                     self.exitSOSPetInfo, ['SOS', 'AttackWait']),
         State.State('Fire', self.enterFire, self.exitFire,
                     ['Attack', 'AttackWait'])
     ], 'Off', 'Off')
     self.runPanel = TTDialog.TTDialog(dialogName='TownBattleRunPanel',
                                       text=TTLocalizer.TownBattleRun,
                                       style=TTDialog.TwoChoice,
                                       command=self.__handleRunPanelDone)
     self.runPanel.hide()
     self.attackPanelDoneEvent = 'attack-panel-done'
     self.attackPanel = TownBattleAttackPanel.TownBattleAttackPanel(
         self.attackPanelDoneEvent)
     self.waitPanelDoneEvent = 'wait-panel-done'
     self.waitPanel = TownBattleWaitPanel.TownBattleWaitPanel(
         self.waitPanelDoneEvent)
     self.chooseCogPanelDoneEvent = 'choose-cog-panel-done'
     self.chooseCogPanel = TownBattleChooseAvatarPanel.TownBattleChooseAvatarPanel(
         self.chooseCogPanelDoneEvent, 0)
     self.chooseToonPanelDoneEvent = 'choose-toon-panel-done'
     self.chooseToonPanel = TownBattleChooseAvatarPanel.TownBattleChooseAvatarPanel(
         self.chooseToonPanelDoneEvent, 1)
     self.SOSPanelDoneEvent = 'SOS-panel-done'
     self.SOSPanel = TownBattleSOSPanel.TownBattleSOSPanel(
         self.SOSPanelDoneEvent)
     self.SOSPetSearchPanelDoneEvent = 'SOSPetSearch-panel-done'
     self.SOSPetSearchPanel = TownBattleSOSPetSearchPanel.TownBattleSOSPetSearchPanel(
         self.SOSPetSearchPanelDoneEvent)
     self.SOSPetInfoPanelDoneEvent = 'SOSPetInfo-panel-done'
     self.SOSPetInfoPanel = TownBattleSOSPetInfoPanel.TownBattleSOSPetInfoPanel(
         self.SOSPetInfoPanelDoneEvent)
     self.fireCogPanelDoneEvent = 'fire-cog-panel-done'
     self.FireCogPanel = FireCogPanel.FireCogPanel(
         self.fireCogPanelDoneEvent)
     self.cogFireCosts = [None, None, None, None]
     self.toonPanels = (TownBattleToonPanel.TownBattleToonPanel(0),
                        TownBattleToonPanel.TownBattleToonPanel(1),
                        TownBattleToonPanel.TownBattleToonPanel(2),
                        TownBattleToonPanel.TownBattleToonPanel(3))
     self.timer = ToontownTimer.ToontownTimer()
     self.timer.posInTopRightCorner()
     self.timer.setScale(0.4)
     self.timer.hide()
     return
 def __init__(self, loader, parentFSM, doneEvent):
     Place.Place.__init__(self, loader, doneEvent)
     self.fsm = ClassicFSM.ClassicFSM('CogdoInterior', [
         State.State('entrance', self.enterEntrance, self.exitEntrance,
                     ['Game', 'walk']),
         State.State('Elevator', self.enterElevator, self.exitElevator,
                     ['Game', 'battle', 'walk', 'crane']),
         State.State('Game', self.enterGame, self.exitGame,
                     ['battle', 'died', 'crane', 'walk']),
         State.State('battle', self.enterBattle, self.exitBattle,
                     ['walk', 'died']),
         State.State(
             'crane', self.enterCrane, self.exitCrane,
             ['walk', 'battle', 'finalBattle', 'died', 'ouch', 'squished']),
         State.State('walk', self.enterWalk, self.exitWalk, [
             'stickerBook', 'stopped', 'battle', 'sit', 'died',
             'teleportOut', 'Elevator', 'crane'
         ]),
         State.State('sit', self.enterSit, self.exitSit, ['walk']),
         State.State(
             'stickerBook', self.enterStickerBook, self.exitStickerBook,
             ['walk', 'stopped', 'sit', 'died', 'teleportOut', 'Elevator']),
         State.State('teleportIn', self.enterTeleportIn,
                     self.exitTeleportIn, ['walk']),
         State.State('teleportOut', self.enterTeleportOut,
                     self.exitTeleportOut, ['teleportIn']),
         State.State('stopped', self.enterStopped, self.exitStopped,
                     ['walk', 'elevatorOut', 'battle']),
         State.State('died', self.enterDied, self.exitDied, []),
         State.State('elevatorOut', self.enterElevatorOut,
                     self.exitElevatorOut, [])
     ], 'entrance', 'elevatorOut')
     self.parentFSM = parentFSM
     self.elevatorDoneEvent = 'elevatorDoneSI'
     self.currentFloor = 0
 def __init__(self, cr):
     DistributedMinigame.__init__(self, cr)
     self.gameFSM = ClassicFSM.ClassicFSM('DistributedRingGame', [State.State('off', self.enterOff, self.exitOff, ['swim']), State.State('swim', self.enterSwim, self.exitSwim, ['cleanup']), State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup')
     self.addChildGameFSM(self.gameFSM)
    def __init__(self, cr):
        try:
            self.DistributedSuit_initialized
            return
        except:
            self.DistributedSuit_initialized = 1

        DistributedSuitBase.DistributedSuitBase.__init__(self, cr)
        self.spDoId = None
        self.pathEndpointStart = 0
        self.pathEndpointEnd = 0
        self.minPathLen = 0
        self.maxPathLen = 0
        self.pathPositionIndex = 0
        self.pathPositionTimestamp = 0.0
        self.pathState = 0
        self.path = None
        self.localPathState = 0
        self.currentLeg = -1
        self.pathStartTime = 0.0
        self.legList = None
        self.initState = None
        self.finalState = None
        self.buildingSuit = 0
        self.fsm = ClassicFSM.ClassicFSM('DistributedSuit', [
            State.State('Off', self.enterOff, self.exitOff, [
                'FromSky', 'FromSuitBuilding', 'Walk', 'Battle', 'neutral',
                'ToToonBuilding', 'ToSuitBuilding', 'ToCogHQ', 'FromCogHQ',
                'ToSky', 'FlyAway', 'DanceThenFlyAway', 'WalkToStreet',
                'WalkFromStreet'
            ]),
            State.State(
                'FromSky', self.enterFromSky, self.exitFromSky,
                ['Walk', 'Battle', 'neutral', 'ToSky', 'WalkFromStreet']),
            State.State(
                'FromSuitBuilding', self.enterFromSuitBuilding,
                self.exitFromSuitBuilding,
                ['WalkToStreet', 'Walk', 'Battle', 'neutral', 'ToSky']),
            State.State(
                'WalkToStreet', self.enterWalkToStreet, self.exitWalkToStreet,
                [
                    'Walk', 'Battle', 'neutral', 'ToSky', 'ToToonBuilding',
                    'ToSuitBuilding', 'ToCogHQ', 'WalkFromStreet'
                ]),
            State.State('WalkFromStreet', self.enterWalkFromStreet,
                        self.exitWalkFromStreet, [
                            'ToToonBuilding', 'ToSuitBuilding', 'ToCogHQ',
                            'Battle', 'neutral', 'ToSky'
                        ]),
            State.State('Walk', self.enterWalk, self.exitWalk, [
                'WaitForBattle', 'Battle', 'neutral', 'WalkFromStreet',
                'ToSky', 'ToCogHQ', 'Walk'
            ]),
            State.State('Battle', self.enterBattle, self.exitBattle, [
                'Walk', 'ToToonBuilding', 'ToCogHQ', 'ToSuitBuilding', 'ToSky'
            ]),
            State.State('neutral', self.enterNeutral, self.exitNeutral, []),
            State.State('WaitForBattle', self.enterWaitForBattle,
                        self.exitWaitForBattle, [
                            'Battle', 'neutral', 'Walk', 'WalkToStreet',
                            'WalkFromStreet', 'ToToonBuilding', 'ToCogHQ',
                            'ToSuitBuilding', 'ToSky'
                        ]),
            State.State('ToToonBuilding', self.enterToToonBuilding,
                        self.exitToToonBuilding, ['neutral', 'Battle']),
            State.State('ToSuitBuilding', self.enterToSuitBuilding,
                        self.exitToSuitBuilding, ['neutral', 'Battle']),
            State.State('ToCogHQ', self.enterToCogHQ, self.exitToCogHQ,
                        ['neutral', 'Battle']),
            State.State('FromCogHQ', self.enterFromCogHQ, self.exitFromCogHQ,
                        ['neutral', 'Battle', 'Walk']),
            State.State('ToSky', self.enterToSky, self.exitToSky, ['Battle']),
            State.State('FlyAway', self.enterFlyAway, self.exitFlyAway, []),
            State.State('DanceThenFlyAway', self.enterDanceThenFlyAway,
                        self.exitDanceThenFlyAway, [])
        ], 'Off', 'Off')
        self.fsm.enterInitialState()
        self.soundSequenceList = []
        self.__currentDialogue = None
        return
Example #20
0
 def load(self):
     self.fsm = ClassicFSM.ClassicFSM('FactoryExterior', [
         State.State('start', self.enterStart, self.exitStart,
                     ['walk', 'tunnelIn', 'teleportIn', 'doorIn']),
         State.State('walk', self.enterWalk, self.exitWalk, [
             'stickerBook', 'teleportOut', 'tunnelOut', 'DFA', 'doorOut',
             'elevator', 'stopped', 'WaitForBattle', 'battle'
         ]),
         State.State('stopped', self.enterStopped, self.exitStopped,
                     ['walk', 'teleportOut', 'elevator']),
         State.State(
             'stickerBook', self.enterStickerBook, self.exitStickerBook,
             ['walk', 'DFA', 'WaitForBattle', 'battle', 'elevator']),
         State.State('WaitForBattle', self.enterWaitForBattle,
                     self.exitWaitForBattle, ['battle', 'walk']),
         State.State('battle', self.enterBattle, self.exitBattle,
                     ['walk', 'teleportOut', 'died']),
         State.State('DFA', self.enterDFA, self.exitDFA,
                     ['DFAReject', 'teleportOut', 'tunnelOut']),
         State.State('DFAReject', self.enterDFAReject, self.exitDFAReject,
                     ['walk']),
         State.State('teleportIn', self.enterTeleportIn,
                     self.exitTeleportIn, ['walk']),
         State.State('teleportOut', self.enterTeleportOut,
                     self.exitTeleportOut,
                     ['teleportIn', 'final', 'WaitForBattle']),
         State.State('doorIn', self.enterDoorIn, self.exitDoorIn, ['walk']),
         State.State('doorOut', self.enterDoorOut, self.exitDoorOut,
                     ['walk']),
         State.State('died', self.enterDied, self.exitDied, ['quietZone']),
         State.State('tunnelIn', self.enterTunnelIn, self.exitTunnelIn,
                     ['walk']),
         State.State('tunnelOut', self.enterTunnelOut, self.exitTunnelOut,
                     ['final']),
         State.State('elevator', self.enterElevator, self.exitElevator,
                     ['walk', 'stopped']),
         State.State('final', self.enterFinal, self.exitFinal, ['start'])
     ], 'start', 'final')
     self.parentFSM.getStateNamed('factoryExterior').addChild(self.fsm)
     BattlePlace.BattlePlace.load(self)
Example #21
0
 def __init__(self, cr):
     DistributedObject.DistributedObject.__init__(self, cr)
     self.toons = []
     self.activeIntervals = {}
     self.openSfx = base.loader.loadSfx('phase_5/audio/sfx/elevator_door_open.ogg')
     self.closeSfx = base.loader.loadSfx('phase_5/audio/sfx/elevator_door_close.ogg')
     self.suits = []
     self.reserveSuits = []
     self.joiningReserves = []
     self.distBldgDoId = None
     self._CogdoGameRepeat = config.GetBool('cogdo-game-repeat', 0)
     self.currentFloor = -1
     self.elevatorName = self.__uniqueName('elevator')
     self.floorModel = None
     self.elevatorOutOpen = 0
     self.BottomFloor_SuitPositions = [Point3(0, 15, 0),
      Point3(10, 20, 0),
      Point3(-7, 24, 0),
      Point3(-10, 0, 0)]
     self.BottomFloor_SuitHs = [75,
      170,
      -91,
      -44]
     self.Cubicle_SuitPositions = [Point3(0, 18, 0),
      Point3(10, 12, 0),
      Point3(-9, 11, 0),
      Point3(-3, 13, 0)]
     self.Cubicle_SuitHs = [170,
      56,
      -52,
      10]
     self.BossOffice_SuitPositions = [Point3(0, 15, 0),
      Point3(10, 20, 0),
      Point3(-10, 6, 0),
      Point3(-17, 30, 0)]
     self.BossOffice_SuitHs = [170,
      120,
      12,
      38]
     self._wantBarrelRoom = config.GetBool('cogdo-want-barrel-room', 1)
     self.barrelRoom = CogdoBarrelRoom.CogdoBarrelRoom()
     self.brResults = [[], []]
     self.barrelRoomIntroTrack = None
     self.penthouseOutroTrack = None
     self.penthouseOutroChatDoneTrack = None
     self.penthouseIntroTrack = None
     self.waitMusic = base.loader.loadMusic('phase_7/audio/bgm/encntr_toon_winning_indoor.ogg')
     self.elevatorMusic = base.loader.loadMusic('phase_7/audio/bgm/tt_elevator.ogg')
     self.fsm = ClassicFSM.ClassicFSM('DistributedCogdoInterior', [State.State('WaitForAllToonsInside', self.enterWaitForAllToonsInside, self.exitWaitForAllToonsInside, ['Elevator']),
      State.State('Elevator', self.enterElevator, self.exitElevator, ['Game']),
      State.State('Game', self.enterGame, self.exitGame, ['Resting', 'Failed', 'BattleIntro']),
      State.State('BarrelRoomIntro', self.enterBarrelRoomIntro, self.exitBarrelRoomIntro, ['CollectBarrels', 'Off']),
      State.State('CollectBarrels', self.enterCollectBarrels, self.exitCollectBarrels, ['BarrelRoomReward', 'Off']),
      State.State('BarrelRoomReward', self.enterBarrelRoomReward, self.exitBarrelRoomReward, ['Battle',
       'ReservesJoining',
       'BattleIntro',
       'Off']),
      State.State('BattleIntro', self.enterBattleIntro, self.exitBattleIntro, ['Battle', 'ReservesJoining', 'Off']),
      State.State('Battle', self.enterBattle, self.exitBattle, ['Resting', 'Reward', 'ReservesJoining']),
      State.State('ReservesJoining', self.enterReservesJoining, self.exitReservesJoining, ['Battle']),
      State.State('Resting', self.enterResting, self.exitResting, ['Elevator', 'BarrelRoomIntro']),
      State.State('Reward', self.enterReward, self.exitReward, ['Off']),
      State.State('Failed', self.enterFailed, self.exitFailed, ['Off']),
      State.State('Off', self.enterOff, self.exitOff, ['Elevator', 'WaitForAllToonsInside', 'Battle'])], 'Off', 'Off')
     self.fsm.enterInitialState()
     self._haveEntranceElevator = StateVar(False)
     self._stashEntranceElevator = StateVar(False)
     self._stashEntranceElevatorFC = FunctionCall(self._doStashEntranceElevator, self._haveEntranceElevator, self._stashEntranceElevator)
     self._entranceElevCallbacks = []
     self._doEntranceElevCallbacksFC = FunctionCall(self._doEntranceElevCallbacks, self._haveEntranceElevator)
     self.cage = None
     self.shopOwnerNpcId = None
     self.shopOwnerNpc = None
     self._movie = None
     self.SOSToonName = None
     self.FOType = None
     return
Example #22
0
 def __init__(self, cr):
     if hasattr(self, 'fishInit'):
         return
     self.fishInit = 1
     DistributedObject.DistributedObject.__init__(self, cr)
     self.lastAvId = 0
     self.lastFrame = 0
     self.avId = 0
     self.av = None
     self.placedAvatar = 0
     self.localToonFishing = 0
     self.nodePath = None
     self.collSphere = None
     self.collNode = None
     self.collNodePath = None
     self.castTrack = None
     self.pond = None
     self.guiTrack = None
     self.madeGui = 0
     self.castGui = None
     self.itemGui = None
     self.pole = None
     self.line = None
     self.poleNode = []
     self.ptop = None
     self.bob = None
     self.bobBobTask = None
     self.splashSounds = None
     self.ripples = None
     self.line = None
     self.lineSphere = None
     self.power = 0.0
     self.startAngleNP = 0
     self.firstCast = 1
     self.fishPanel = None
     self.fsm = ClassicFSM.ClassicFSM('DistributedFishingSpot', [State.State('off', self.enterOff, self.exitOff, ['waiting',
       'distCasting',
       'fishing',
       'reward',
       'leaving']),
      State.State('waiting', self.enterWaiting, self.exitWaiting, ['localAdjusting',
       'distCasting',
       'leaving',
       'sellFish']),
      State.State('localAdjusting', self.enterLocalAdjusting, self.exitLocalAdjusting, ['localCasting', 'leaving']),
      State.State('localCasting', self.enterLocalCasting, self.exitLocalCasting, ['localAdjusting', 'fishing', 'leaving']),
      State.State('distCasting', self.enterDistCasting, self.exitDistCasting, ['fishing', 'leaving', 'reward']),
      State.State('fishing', self.enterFishing, self.exitFishing, ['localAdjusting',
       'distCasting',
       'waitForAI',
       'reward',
       'leaving']),
      State.State('sellFish', self.enterSellFish, self.exitSellFish, ['waiting', 'leaving']),
      State.State('waitForAI', self.enterWaitForAI, self.exitWaitForAI, ['reward', 'leaving']),
      State.State('reward', self.enterReward, self.exitReward, ['localAdjusting',
       'distCasting',
       'leaving',
       'sellFish']),
      State.State('leaving', self.enterLeaving, self.exitLeaving, [])], 'off', 'off')
     self.fsm.enterInitialState()
     return
 def __init__(self, loader, parentFSM, doneEvent):
     BattlePlace.BattlePlace.__init__(self, loader, doneEvent)
     self.parentFSM = parentFSM
     self.zoneId = loader.countryClubId
     self.elevatorDoneEvent = 'elevatorDone'
     self.fsm = ClassicFSM.ClassicFSM('CountryClubInterior', [
         State.State('start', self.enterStart, self.exitStart,
                     ['walk', 'teleportIn', 'fallDown']),
         State.State('walk', self.enterWalk, self.exitWalk, [
             'push', 'sit', 'stickerBook', 'WaitForBattle', 'battle',
             'died', 'teleportOut', 'squished', 'DFA', 'fallDown',
             'stopped', 'elevator'
         ]),
         State.State('stopped', self.enterStopped, self.exitStopped,
                     ['walk', 'teleportOut', 'stickerBook']),
         State.State('sit', self.enterSit, self.exitSit,
                     ['walk', 'died', 'teleportOut']),
         State.State('push', self.enterPush, self.exitPush,
                     ['walk', 'died', 'teleportOut']),
         State.State('stickerBook', self.enterStickerBook,
                     self.exitStickerBook, [
                         'walk', 'battle', 'DFA', 'WaitForBattle', 'died',
                         'teleportOut'
                     ]),
         State.State('WaitForBattle', self.enterWaitForBattle,
                     self.exitWaitForBattle,
                     ['battle', 'walk', 'died', 'teleportOut']),
         State.State('battle', self.enterBattle, self.exitBattle,
                     ['walk', 'teleportOut', 'died']),
         State.State('fallDown', self.enterFallDown, self.exitFallDown,
                     ['walk', 'died', 'teleportOut']),
         State.State('squished', self.enterSquished, self.exitSquished,
                     ['walk', 'died', 'teleportOut']),
         State.State('teleportIn', self.enterTeleportIn,
                     self.exitTeleportIn,
                     ['walk', 'teleportOut', 'quietZone', 'died']),
         State.State('teleportOut', self.enterTeleportOut,
                     self.exitTeleportOut,
                     ['teleportIn', 'FLA', 'quietZone', 'WaitForBattle']),
         State.State('DFA', self.enterDFA, self.exitDFA,
                     ['DFAReject', 'teleportOut']),
         State.State('DFAReject', self.enterDFAReject, self.exitDFAReject,
                     ['walkteleportOut']),
         State.State('died', self.enterDied, self.exitDied,
                     ['teleportOut']),
         State.State('FLA', self.enterFLA, self.exitFLA, ['quietZone']),
         State.State('quietZone', self.enterQuietZone, self.exitQuietZone,
                     ['teleportIn']),
         State.State('elevator', self.enterElevator, self.exitElevator,
                     ['walk']),
         State.State('final', self.enterFinal, self.exitFinal, ['start'])
     ], 'start', 'final')
Example #24
0
    def __init__(self, cr):
        NodePath.__init__(self, "DistributedFindFour")
        DistributedNode.DistributedNode.__init__(self, cr)
        self.cr = cr

        self.reparentTo(render)
        self.boardNode = loader.loadModel(
            "phase_6/models/golf/findfour_game.bam")
        self.boardNode.reparentTo(self)
        #self.boardNode.setScale(.05)

        self.board = [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
                      [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
                      [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]

        #game variables
        self.exitButton = None
        self.inGame = False
        self.waiting = True
        self.startButton = None
        self.playerNum = None
        self.turnText = None
        self.isMyTurn = False
        self.wantTimer = True
        self.leaveButton = None
        self.screenText = None
        self.turnText = None
        self.exitButton = None
        self.numRandomMoves = 0
        self.blinker = Sequence()
        self.playersTurnBlinker = Sequence()
        self.yourTurnBlinker = Sequence()
        self.winningSequence = Sequence()
        self.moveSequence = Sequence()
        self.moveList = []
        self.mySquares = []
        self.playerSeats = None
        self.moveCol = None

        self.move = None
        ###self.playerTags = [None, None, None, None, None, None

        #Mouse picking required stuff
        self.accept('mouse1', self.mouseClick)
        self.traverser = base.cTrav
        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(BitMask32(0x1000))
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
        self.myHandler = CollisionHandlerQueue()
        self.traverser.addCollider(self.pickerNP, self.myHandler)

        self.buttonModels = loader.loadModel(
            "phase_3.5/models/gui/inventory_gui")
        self.upButton = self.buttonModels.find("**//InventoryButtonUp")
        self.downButton = self.buttonModels.find("**/InventoryButtonDown")
        self.rolloverButton = self.buttonModels.find(
            "**/InventoryButtonRollover")

        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.16, 0, -0.83)
        self.clockNode.setScale(0.3)
        self.clockNode.hide()

        self.tintConstant = Vec4(.25, .25, .25, 0)
        self.ghostConstant = Vec4(0, 0, 0, .5)

        self.knockSound = base.loadSfx("phase_5/audio/sfx/GUI_knock_1.mp3")
        self.clickSound = base.loadSfx(
            "phase_3/audio/sfx/GUI_balloon_popup.mp3")
        self.moveSound = base.loadSfx("phase_6/audio/sfx/CC_move.mp3")
        self.accept('stoppedAsleep', self.handleSleep)

        #######################
        #Fsm and State Data
        from direct.fsm import ClassicFSM, State
        self.fsm = ClassicFSM.ClassicFSM(
            'ChineseCheckers',
            [
                State.State('waitingToBegin', self.enterWaitingToBegin,
                            self.exitWaitingToBegin, ['playing', 'gameOver']),
                State.State('playing', self.enterPlaying, self.exitPlaying,
                            ['gameOver']),
                State.State('gameOver', self.enterGameOver, self.exitGameOver,
                            ['waitingToBegin'])
            ],
            # Initial State
            'waitingToBegin',
            # Final State
            'waitingToBegin',
        )

        #########################
        #Set up the Board Locators
        ##
        startLoc = self.boardNode.find("**/locators")
        self.locatorList = startLoc.getChildren()

        self.startingPositions = self.locatorList.pop(0)
        self.startingPositions = self.startingPositions.getChildren()

        instancePiece = self.boardNode.find("**/pieces")

        #tag the locators for "picking" ingame
        #also add colision spheres for movement
        tempList = []

        #Start Position locators
        #Up above the board
        for x in range(7):
            self.startingPositions[x].setTag("StartLocator", "%d" % x)
            collNode = CollisionNode("startpicker%d" % x)
            collNode.setIntoCollideMask(BitMask32(0x1000))
            tempList.append(self.startingPositions[x].attachNewNode(collNode))
            tempList[x].node().addSolid(
                CollisionTube(0, 0, .23, 0, 0, -.23, .2))
        for z in self.startingPositions:
            y = instancePiece.copyTo(z)
            for val in y.getChildren():
                val.hide()

        tempList = []
        #the peices themselves inside of the board.
        for x in range(42):
            self.locatorList[x].setTag("GamePeiceLocator", "%d" % x)
            collNode = CollisionNode("startpicker%d" % x)
            collNode.setIntoCollideMask(BitMask32(0x1000))
            tempList.append(self.locatorList[x].attachNewNode(collNode))
            tempList[x].node().addSolid(CollisionSphere(0, 0, 0, .2))
        for z in self.locatorList:
            y = instancePiece.copyTo(z)
            for val in y.getChildren():
                val.hide()

        dummyHide = instancePiece.getParent().attachNewNode("DummyHider")
        instancePiece.reparentTo(dummyHide)
        dummyHide.hide()
Example #25
0
 def __init__(self, loader, avId, zoneId, parentFSMState, doneEvent):
     Place.Place.__init__(self, None, doneEvent)
     self.id = MyEstate
     self.avId = avId
     self.zoneId = zoneId
     self.loader = loader
     self.cameraSubmerged = -1
     self.toonSubmerged = -1
     self.fsm = ClassicFSM.ClassicFSM('Estate', [State.State('init', self.enterInit, self.exitInit, ['final',
       'teleportIn',
       'doorIn',
       'walk']),
      State.State('petTutorial', self.enterPetTutorial, self.exitPetTutorial, ['walk']),
      State.State('walk', self.enterWalk, self.exitWalk, ['final',
       'sit',
       'stickerBook',
       'options',
       'quest',
       'fishing',
       'mailbox',
       'stopped',
       'DFA',
       'trialerFA',
       'doorOut',
       'push',
       'pet']),
      State.State('stopped', self.enterStopped, self.exitStopped, ['walk', 'teleportOut']),
      State.State('sit', self.enterSit, self.exitSit, ['walk']),
      State.State('push', self.enterPush, self.exitPush, ['walk']),
      State.State('stickerBook', self.enterStickerBook, self.exitStickerBook, ['walk',
       'sit',
       'quest',
       'fishing',
       'mailbox',
       'stopped',
       'doorOut',
       'push',
       'pet',
       'DFA',
       'trialerFA']),
      State.State('teleportIn', self.enterTeleportIn, self.exitTeleportIn, ['walk', 'petTutorial']),
      State.State('teleportOut', self.enterTeleportOut, self.exitTeleportOut, ['teleportIn', 'walk', 'final']),
      State.State('doorIn', self.enterDoorIn, self.exitDoorIn, ['walk']),
      State.State('doorOut', self.enterDoorOut, self.exitDoorOut, ['final', 'walk']),
      State.State('final', self.enterFinal, self.exitFinal, ['teleportIn']),
      State.State('quest', self.enterQuest, self.exitQuest, ['walk']),
      State.State('fishing', self.enterFishing, self.exitFishing, ['walk', 'stopped']),
      State.State('mailbox', self.enterMailbox, self.exitMailbox, ['walk', 'stopped']),
      State.State('stopped', self.enterStopped, self.exitStopped, ['walk']),
      State.State('pet', self.enterPet, self.exitPet, ['walk', 'trialerFA']),
      State.State('trialerFA', self.enterTrialerFA, self.exitTrialerFA, ['trialerFAReject', 'DFA']),
      State.State('trialerFAReject', self.enterTrialerFAReject, self.exitTrialerFAReject, ['walk']),
      State.State('DFA', self.enterDFA, self.exitDFA, ['DFAReject', 'teleportOut']),
      State.State('DFAReject', self.enterDFAReject, self.exitDFAReject, ['walk'])], 'init', 'final')
     self.fsm.enterInitialState()
     self.doneEvent = doneEvent
     self.parentFSMState = parentFSMState
     return
Example #26
0
 def __init__(self, loader, avId, zoneId, parentFSMState, doneEvent):
     Place.Place.__init__(self, None, doneEvent)
     self.id = PartyHood
     self.avId = avId
     self.zoneId = zoneId
     self.loader = loader
     self.musicShouldPlay = False
     self.partyPlannerDoneEvent = 'partyPlannerGuiDone'
     self.fsm = ClassicFSM.ClassicFSM('Party', [
         State.State('init', self.enterInit, self.exitInit,
                     ['final', 'teleportIn', 'walk']),
         State.State('walk', self.enterWalk, self.exitWalk, [
             'final', 'sit', 'stickerBook', 'options', 'quest', 'fishing',
             'stopped', 'DFA', 'trialerFA', 'push', 'activity'
         ]),
         State.State('stopped', self.enterStopped, self.exitStopped,
                     ['walk', 'teleportOut']),
         State.State('sit', self.enterSit, self.exitSit, ['walk']),
         State.State('push', self.enterPush, self.exitPush, ['walk']),
         State.State('partyPlanning', self.enterPartyPlanning,
                     self.exitPartyPlanning, ['DFA', 'teleportOut']),
         State.State(
             'stickerBook', self.enterStickerBook, self.exitStickerBook, [
                 'walk', 'sit', 'quest', 'fishing', 'stopped', 'activity',
                 'push', 'DFA', 'trialerFA'
             ]),
         State.State('teleportIn', self.enterTeleportIn,
                     self.exitTeleportIn, ['walk', 'partyPlanning']),
         State.State('teleportOut', self.enterTeleportOut,
                     self.exitTeleportOut, ['teleportIn', 'walk', 'final']),
         State.State('died', self.enterDied, self.exitDied,
                     ['walk', 'final']),
         State.State('final', self.enterFinal, self.exitFinal,
                     ['teleportIn']),
         State.State('quest', self.enterQuest, self.exitQuest, ['walk']),
         State.State('fishing', self.enterFishing, self.exitFishing,
                     ['walk', 'stopped']),
         State.State('activity', self.enterActivity, self.exitActivity,
                     ['walk', 'stopped']),
         State.State('stopped', self.enterStopped, self.exitStopped,
                     ['walk']),
         State.State('trialerFA', self.enterTrialerFA, self.exitTrialerFA,
                     ['trialerFAReject', 'DFA']),
         State.State('trialerFAReject', self.enterTrialerFAReject,
                     self.exitTrialerFAReject, ['walk']),
         State.State('DFA', self.enterDFA, self.exitDFA,
                     ['DFAReject', 'teleportOut']),
         State.State('DFAReject', self.enterDFAReject, self.exitDFAReject,
                     ['walk'])
     ], 'init', 'final')
     self.fsm.enterInitialState()
     self.doneEvent = doneEvent
     self.parentFSMState = parentFSMState
     self.isPartyEnding = False
     self.accept('partyStateChanged', self.setPartyState)
Example #27
0
    def __init__(self, cr):
        NodePath.__init__(self, "DistributedChineseCheckers")
        DistributedNode.DistributedNode.__init__(self, cr)
        self.cr = cr

        self.reparentTo(render)
        self.boardNode = loader.loadModel(
            "phase_6/models/golf/checker_game.bam")
        self.boardNode.reparentTo(self)
        #self.boardNode.setZ(2.85)
        #self.boardNode.setZ(3.5)
        #self.boardNode.setZ(0.3)
        #self.boardNode.setZ(self.getZ())

        self.board = ChineseCheckersBoard()

        self.playerTags = render.attachNewNode("playerTags")
        self.playerTagList = []

        #game variables
        self.exitButton = None
        self.inGame = False
        self.waiting = True
        self.startButton = None
        self.playerNum = None
        self.turnText = None
        self.isMyTurn = False
        self.wantTimer = True
        self.leaveButton = None
        self.screenText = None
        self.turnText = None
        self.exitButton = None
        self.numRandomMoves = 0
        self.blinker = Sequence()
        self.playersTurnBlinker = Sequence()
        self.yourTurnBlinker = Sequence()
        self.moveList = []
        self.mySquares = []
        self.playerSeats = None
        ###self.playerTags = [None, None, None, None, None, None

        #Mouse picking required stuff
        self.accept('mouse1', self.mouseClick)
        self.traverser = base.cTrav
        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(ToontownGlobals.WallBitmask)
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
        self.myHandler = CollisionHandlerQueue()
        self.traverser.addCollider(self.pickerNP, self.myHandler)

        self.buttonModels = loader.loadModel(
            "phase_3.5/models/gui/inventory_gui")
        self.upButton = self.buttonModels.find("**//InventoryButtonUp")
        self.downButton = self.buttonModels.find("**/InventoryButtonDown")
        self.rolloverButton = self.buttonModels.find(
            "**/InventoryButtonRollover")

        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.16, 0, -0.83)
        self.clockNode.setScale(0.3)
        self.clockNode.hide()

        #[0] GREEN [1] YELLOW [2] PURPLE [3] BLUE [4] PINK [5] RED
        self.playerColors = [
            Vec4(0, .90, 0, 1),
            Vec4(.9, .9, 0, 1),
            Vec4(.45, 0, .45, 1),
            Vec4(.2, .4, .8, 1),
            Vec4(1, .45, 1, 1),
            Vec4(.8, 0, 0, 1)
        ]
        self.tintConstant = Vec4(.25, .25, .25, 0)
        self.ghostConstant = Vec4(0, 0, 0, .5)

        #starting positions are used to check and see if a player has gone into
        #his opposing players starting position, thus to tell if he won.
        self.startingPositions = [
            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
            [10, 11, 12, 13, 23, 24, 25, 35, 36, 46],
            [65, 75, 76, 86, 87, 88, 98, 99, 100, 101],
            [111, 112, 113, 114, 115, 116, 117, 118, 119, 120],
            [74, 84, 85, 95, 96, 97, 107, 108, 109, 110],
            [19, 20, 21, 22, 32, 33, 34, 44, 45, 55]
        ]
        self.nonOpposingPositions = []

        self.knockSound = base.loader.loadSfx(
            "phase_5/audio/sfx/GUI_knock_1.mp3")
        self.clickSound = base.loader.loadSfx(
            "phase_3/audio/sfx/GUI_balloon_popup.mp3")
        self.moveSound = base.loader.loadSfx("phase_6/audio/sfx/CC_move.mp3")
        self.accept('stoppedAsleep', self.handleSleep)

        #base.setCellsAvailable(base.leftCells +
        #[base.bottomCells[0]], 0)

        #base.setCellsAvailable(base.bottomCells,0)

        #######################
        #Fsm and State Data
        from direct.fsm import ClassicFSM, State
        self.fsm = ClassicFSM.ClassicFSM(
            'ChineseCheckers',
            [
                State.State('waitingToBegin', self.enterWaitingToBegin,
                            self.exitWaitingToBegin, ['playing', 'gameOver']),
                State.State('playing', self.enterPlaying, self.exitPlaying,
                            ['gameOver']),
                State.State('gameOver', self.enterGameOver, self.exitGameOver,
                            ['waitingToBegin'])
            ],
            # Initial State
            'waitingToBegin',
            # Final State
            'waitingToBegin',
        )

        #########################
        #Set up the Board Locators
        ##
        x = self.boardNode.find("**/locators")
        #set up the locator list so we can mess with it
        self.locatorList = x.getChildren()
        #tag the locators for "picking" ingame
        #also add colision spheres for movement
        tempList = []
        for x in range(0, 121):
            self.locatorList[x].setTag("GamePeiceLocator", "%d" % x)
            tempList.append(self.locatorList[x].attachNewNode(
                CollisionNode("picker%d" % x)))
            tempList[x].node().addSolid(CollisionSphere(0, 0, 0, .115))
        for z in self.locatorList:
            y = loader.loadModel("phase_6/models/golf/checker_marble.bam")
            z.setColor(0, 0, 0, 0)
            y.reparentTo(z)
Example #28
0
    def __init__(self, cr):
        NodePath.__init__(self, 'DistributedCheckers')
        DistributedNode.DistributedNode.__init__(self, cr)
        self.cr = cr
        self.reparentTo(render)
        self.boardNode = loader.loadModel(
            'phase_6/models/golf/regular_checker_game.bam')
        self.boardNode.reparentTo(self)
        self.board = CheckersBoard()
        self.exitButton = None
        self.inGame = False
        self.waiting = True
        self.startButton = None
        self.playerNum = None
        self.turnText = None
        self.isMyTurn = False
        self.wantTimer = True
        self.leaveButton = None
        self.screenText = None
        self.turnText = None
        self.exitButton = None
        self.numRandomMoves = 0
        self.blinker = Sequence()
        self.moveList = []
        self.mySquares = []
        self.myKings = []
        self.isRotated = False
        self.accept('mouse1', self.mouseClick)
        self.traverser = base.cTrav
        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(ToontownGlobals.WallBitmask)
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
        self.myHandler = CollisionHandlerQueue()
        self.traverser.addCollider(self.pickerNP, self.myHandler)
        self.buttonModels = loader.loadModel(
            'phase_3.5/models/gui/inventory_gui')
        self.upButton = self.buttonModels.find('**//InventoryButtonUp')
        self.downButton = self.buttonModels.find('**/InventoryButtonDown')
        self.rolloverButton = self.buttonModels.find(
            '**/InventoryButtonRollover')
        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.16, 0, -0.83)
        self.clockNode.setScale(0.3)
        self.clockNode.hide()
        self.playerColors = [Vec4(0, 0, 1, 1), Vec4(0, 1, 0, 1)]
        self.tintConstant = Vec4(0.25, 0.25, 0.25, 0.5)
        self.ghostConstant = Vec4(0, 0, 0, 0.8)
        self.startingPositions = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
                                  [
                                      20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
                                      30, 31
                                  ]]
        self.knockSound = base.loader.loadSfx(
            'phase_5/audio/sfx/GUI_knock_1.ogg')
        self.clickSound = base.loader.loadSfx(
            'phase_3/audio/sfx/GUI_balloon_popup.ogg')
        self.moveSound = base.loader.loadSfx('phase_6/audio/sfx/CC_move.ogg')
        self.accept('stoppedAsleep', self.handleSleep)
        self.fsm = ClassicFSM.ClassicFSM('ChineseCheckers', [
            State.State('waitingToBegin', self.enterWaitingToBegin,
                        self.exitWaitingToBegin, ['playing', 'gameOver']),
            State.State('playing', self.enterPlaying, self.exitPlaying,
                        ['gameOver']),
            State.State('gameOver', self.enterGameOver, self.exitGameOver,
                        ['waitingToBegin'])
        ], 'waitingToBegin', 'waitingToBegin')
        x = self.boardNode.find('**/locator*')
        self.locatorList = x.getChildren()
        tempList = []
        for x in xrange(0, 32):
            self.locatorList[x].setTag('GamePeiceLocator', '%d' % x)
            tempList.append(self.locatorList[x].attachNewNode(
                CollisionNode('picker%d' % x)))
            tempList[x].node().addSolid(CollisionSphere(0, 0, 0, 0.39))

        for z in self.locatorList:
            y = loader.loadModel(
                'phase_6/models/golf/regular_checker_piecewhite.bam')
            y.find('**/checker_k*').hide()
            zz = loader.loadModel(
                'phase_6/models/golf/regular_checker_pieceblack.bam')
            zz.find('**/checker_k*').hide()
            y.reparentTo(z)
            y.hide()
            zz.reparentTo(z)
            zz.hide()

        return
Example #29
0
    def __init__(self, loader, parentFSM, doneEvent):
        """
        Playground constructor: create a play game ClassicFSM
        """
        assert (self.notify.debug("__init__()"))
        Place.Place.__init__(self, loader, doneEvent)

        self.tfaDoneEvent = "tfaDoneEvent"
        # shared state
        self.fsm = ClassicFSM.ClassicFSM(
            'Playground',
            [
                State.State('start', self.enterStart, self.exitStart,
                            ['walk', 'deathAck', 'doorIn', 'tunnelIn']),
                State.State('walk', self.enterWalk, self.exitWalk, [
                    'drive', 'sit', 'stickerBook', 'TFA', 'DFA', 'trialerFA',
                    'trolley', 'final', 'doorOut', 'options', 'quest',
                    'purchase', 'stopped', 'fishing'
                ]),
                State.State(
                    'stickerBook',
                    self.enterStickerBook,
                    self.exitStickerBook,
                    [
                        'walk',
                        'DFA',
                        'TFA',
                        # You can get to all of these by jumping over
                        # the trigger then opening your book
                        'trolley',
                        'final',
                        'doorOut',
                        'quest',
                        'purchase',
                        'stopped',
                        'fishing',
                        'trialerFA',
                    ]),
                State.State(
                    'sit',
                    self.enterSit,
                    self.exitSit,
                    [
                        'walk',
                        'DFA',  # So you can teleport to a friend
                        'trialerFA',
                    ]),
                State.State(
                    'drive',
                    self.enterDrive,
                    self.exitDrive,
                    [
                        'walk',
                        'DFA',  # So you can teleport to a friend
                        'trialerFA',
                    ]),
                State.State('trolley', self.enterTrolley, self.exitTrolley,
                            ['walk']),
                State.State('doorIn', self.enterDoorIn, self.exitDoorIn,
                            ['walk']),
                State.State('doorOut', self.enterDoorOut, self.exitDoorOut,
                            ['walk']),  # 'final'
                # Tutorial Force Acknowledge:
                State.State('TFA', self.enterTFA, self.exitTFA,
                            ['TFAReject', 'DFA']),
                State.State('TFAReject', self.enterTFAReject,
                            self.exitTFAReject, ['walk']),
                # Trialer Force Acknowledge:
                State.State('trialerFA', self.enterTrialerFA,
                            self.exitTrialerFA, ['trialerFAReject', 'DFA']),
                State.State('trialerFAReject', self.enterTrialerFAReject,
                            self.exitTrialerFAReject, ['walk']),
                # Download Force Acknowledge
                State.State('DFA', self.enterDFA, self.exitDFA,
                            ['DFAReject', 'NPCFA', 'HFA']),
                State.State('DFAReject', self.enterDFAReject,
                            self.exitDFAReject, ['walk']),
                # NPC Force Acknowledge:
                State.State('NPCFA', self.enterNPCFA, self.exitNPCFA,
                            ['NPCFAReject', 'HFA']),
                State.State('NPCFAReject', self.enterNPCFAReject,
                            self.exitNPCFAReject, ['walk']),
                # Health Force Acknowledge
                State.State('HFA', self.enterHFA, self.exitHFA,
                            ['HFAReject', 'teleportOut', 'tunnelOut']),
                State.State('HFAReject', self.enterHFAReject,
                            self.exitHFAReject, ['walk']),
                State.State('deathAck', self.enterDeathAck, self.exitDeathAck,
                            ['teleportIn']),
                State.State('teleportIn', self.enterTeleportIn,
                            self.exitTeleportIn, ['walk', 'popup']),
                State.State('popup', self.enterPopup, self.exitPopup,
                            ['walk']),
                State.State('teleportOut', self.enterTeleportOut,
                            self.exitTeleportOut,
                            ['deathAck', 'teleportIn']),  # 'final'
                State.State(
                    'died',  # No transitions to "died" in the playground.
                    self.enterDied,
                    self.exitDied,
                    ['final']),
                State.State('tunnelIn', self.enterTunnelIn, self.exitTunnelIn,
                            ['walk']),
                State.State('tunnelOut', self.enterTunnelOut,
                            self.exitTunnelOut, ['final']),
                State.State('quest', self.enterQuest, self.exitQuest,
                            ['walk']),
                State.State('purchase', self.enterPurchase, self.exitPurchase,
                            ['walk']),
                State.State('stopped', self.enterStopped, self.exitStopped,
                            ['walk']),
                State.State('fishing', self.enterFishing, self.exitFishing,
                            ['walk']),
                State.State('final', self.enterFinal, self.exitFinal,
                            ['start'])
            ],

            # Initial State
            'start',
            # Final State
            'final',
        )

        self.parentFSM = parentFSM
        self.tunnelOriginList = []
        self.trolleyDoneEvent = "trolleyDone"
        self.hfaDoneEvent = "hfaDoneEvent"
        self.npcfaDoneEvent = "npcfaDoneEvent"
        self.dialog = None
        self.deathAckBox = None
Example #30
0
 def __init__(self, cr):
     DistributedMinigame.__init__(self, cr)
     self.gameFSM = ClassicFSM.ClassicFSM('DistributedRaceGame', [
         State.State('off', self.enterOff, self.exitOff, ['inputChoice']),
         State.State('inputChoice', self.enterInputChoice,
                     self.exitInputChoice,
                     ['waitServerChoices', 'moveAvatars', 'cleanup']),
         State.State('waitServerChoices', self.enterWaitServerChoices,
                     self.exitWaitServerChoices,
                     ['moveAvatars', 'cleanup']),
         State.State('moveAvatars', self.enterMoveAvatars,
                     self.exitMoveAvatars,
                     ['inputChoice', 'winMovie', 'cleanup']),
         State.State('winMovie', self.enterWinMovie, self.exitWinMovie,
                     ['cleanup']),
         State.State('cleanup', self.enterCleanup, self.exitCleanup, [])
     ], 'off', 'cleanup')
     self.addChildGameFSM(self.gameFSM)
     self.posHprArray = (
         ((-9.03, 0.06, 0.025, -152.9), (-7.43, -2.76, 0.025, -152.68),
          (-6.02, -5.48, 0.025, -157.54), (-5.01, -8.32, 0.025, -160.66),
          (-4.05, -11.36, 0.025, -170.22), (-3.49, -14.18, 0.025, -175.76),
          (-3.12, -17.15, 0.025, -177.73), (-3.0, -20.32, 0.025, 178.49),
          (-3.09, -23.44, 0.025, 176.59), (-3.43, -26.54, 0.025,
                                           171.44), (-4.07, -29.44, 0.025,
                                                     163.75),
          (-5.09, -32.27, 0.025, 158.2), (-6.11, -35.16, 0.025, 154.98),
          (-7.57, -37.78, 0.025, 154.98), (-9.28, -40.65, 0.025, 150.41)),
         ((-6.12, 1.62, 0.025, -152.9), (-4.38, -1.35, 0.025, -150.92),
          (-3.08, -4.3, 0.025, -157.9),
          (-1.85, -7.26, 0.025, -162.54), (-0.93, -10.49, 0.025, -167.71),
          (-0.21, -13.71, 0.025, -171.79), (0.21, -17.08, 0.025, -174.92),
          (0.31, -20.2, 0.025, 177.1), (0.17, -23.66, 0.025,
                                        174.82), (-0.23, -26.91, 0.025,
                                                  170.51), (-0.99, -30.2,
                                                            0.025, 162.54),
          (-2.02, -33.28, 0.025, 160.48), (-3.28, -36.38, 0.025, 157.96),
          (-4.67, -39.17, 0.025, 154.13), (-6.31, -42.15, 0.025, 154.13)),
         ((-2.99, 3.09, 0.025, -154.37), (-1.38, -0.05, 0.025, -154.75),
          (-0.19, -3.29, 0.025, -159.22), (1.17, -6.51, 0.025, -162.74),
          (2.28, -9.8, 0.025, -168.73), (3.09, -13.28, 0.025, -173.49),
          (3.46, -16.63, 0.025, -176.81), (3.69, -20.38, 0.025, 179.14),
          (3.61, -24.12, 0.025, 175.78), (3.0, -27.55, 0.025, 170.87),
          (2.15, -30.72, 0.025, 167.41), (1.04, -34.26, 0.025, 162.11),
          (-0.15, -37.44, 0.025, 158.59), (-1.64, -40.52, 0.025,
                                           153.89), (-3.42, -43.63, 0.025,
                                                     153.89)),
         ((0.0, 4.35, 0.025, -154.37), (1.52, 1.3, 0.025, -155.67),
          (3.17, -2.07, 0.025, -155.67), (4.47, -5.41, 0.025, -163.0),
          (5.56, -9.19, 0.025, -168.89), (6.22, -12.66, 0.025, -171.67),
          (6.67, -16.56, 0.025, -176.53), (6.93, -20.33, 0.025, 179.87),
          (6.81, -24.32, 0.025, 175.19), (6.22, -27.97, 0.025, 170.81),
          (5.59, -31.73, 0.025, 167.54), (4.48, -35.42, 0.025, 161.92),
          (3.06, -38.82, 0.025, 158.56), (1.4, -42.0, 0.025,
                                          154.32), (-0.71, -45.17, 0.025,
                                                    153.27)))
     self.avatarPositions = {}
     self.modelCount = 8
     self.cameraTopView = (-22.78, -41.65, 31.53, -51.55, -42.68, -2.96)
     self.timer = None
     self.timerStartTime = None
     return None