OTPClientRepository.py

# File: O (Python 2.4)

import sys
import time
import string
import types
import random
import gc
import os
from pandac.PandaModules import *
from pandac.PandaModules import *
from direct.gui.DirectGui import *
from otp.distributed.OtpDoGlobals import *
from direct.interval.IntervalGlobal import ivalMgr
from direct.directnotify.DirectNotifyGlobal import directNotify
from direct.distributed.ClientRepositoryBase import ClientRepositoryBase
from direct.fsm.ClassicFSM import ClassicFSM
from direct.fsm.State import State
from direct.task import Task
from direct.distributed import DistributedSmoothNode
from direct.showbase import PythonUtil, GarbageReport, BulletinBoardWatcher
from direct.showbase.ContainerLeakDetector import ContainerLeakDetector
from direct.showbase import MessengerLeakDetector
from direct.showbase.GarbageReportScheduler import GarbageReportScheduler
from direct.showbase import LeakDetectors
from direct.distributed.PyDatagram import PyDatagram
from direct.distributed.PyDatagramIterator import PyDatagramIterator
from otp.avatar import Avatar
from otp.avatar.DistributedPlayer import DistributedPlayer
from otp.login import TTAccount
from otp.login import LoginTTSpecificDevAccount
from otp.login import AccountServerConstants
from otp.login.CreateAccountScreen import CreateAccountScreen
from otp.login import LoginScreen
from otp.otpgui import OTPDialog
from otp.avatar import DistributedAvatar
from otp.otpbase import OTPLocalizer
from otp.login import LoginGSAccount
from otp.login import LoginGoAccount
from otp.login.LoginWebPlayTokenAccount import LoginWebPlayTokenAccount
from otp.login.LoginDISLTokenAccount import LoginDISLTokenAccount
from otp.login import LoginTTAccount
from otp.login import HTTPUtil
from otp.otpbase import OTPGlobals
from otp.otpbase import OTPLauncherGlobals
from otp.uberdog import OtpAvatarManager
from otp.distributed import OtpDoGlobals
from otp.ai.GarbageLeakServerEventAggregator import GarbageLeakServerEventAggregator
from PotentialAvatar import PotentialAvatar

class OTPClientRepository(ClientRepositoryBase):
    notify = directNotify.newCategory('OTPClientRepository')
    avatarLimit = 6
    WishNameResult = Enum(['Failure', 'PendingApproval', 'Approved', 'Rejected'])
    whiteListChatEnabled = 1
    
    def __init__(self, serverVersion, launcher = None, playGame = None):
        ClientRepositoryBase.__init__(self)
        self.handler = None
        self.launcher = launcher
        base.launcher = launcher
        self._OTPClientRepository__currentAvId = 0
        self.productName = config.GetString('product-name', 'DisneyOnline-US')
        self.createAvatarClass = None
        self.systemMessageSfx = None
        reg_deployment = ''
        if self.productName == 'DisneyOnline-US':
            if self.launcher:
                if self.launcher.isDummy():
                    reg_deployment = self.launcher.getDeployment()
                else:
                    reg_deployment = self.launcher.getRegistry('DEPLOYMENT')
                    if reg_deployment != 'UK' and reg_deployment != 'AP':
                        reg_deployment = self.launcher.getRegistry('GAME_DEPLOYMENT')
                    
                    self.notify.info('reg_deployment=%s' % reg_deployment)
                if reg_deployment == 'UK':
                    self.productName = 'DisneyOnline-UK'
                elif reg_deployment == 'AP':
                    self.productName = 'DisneyOnline-AP'
                
            
        
        self.blue = None
        if self.launcher:
            self.blue = self.launcher.getBlue()
        
        fakeBlue = config.GetString('fake-blue', '')
        if fakeBlue:
            self.blue = fakeBlue
        
        self.playToken = None
        if self.launcher:
            self.playToken = self.launcher.getPlayToken()
        
        fakePlayToken = config.GetString('fake-playtoken', '')
        if fakePlayToken:
            self.playToken = fakePlayToken
        
        self.DISLToken = None
        if self.launcher:
            self.DISLToken = self.launcher.getDISLToken()
        
        fakeDISLToken = config.GetString('fake-DISLToken', '')
        fakeDISLPlayerName = config.GetString('fake-DISL-PlayerName', '')
        if fakeDISLToken:
            self.DISLToken = fakeDISLToken
        elif fakeDISLPlayerName:
            defaultId = 42
            defaultNumAvatars = 4
            defaultNumAvatarSlots = 4
            defaultNumConcur = 1
            subCount = config.GetInt('fake-DISL-NumSubscriptions', 1)
            playerAccountId = config.GetInt('fake-DISL-PlayerAccountId', defaultId)
            self.DISLToken = 'ACCOUNT_NAME=%s' % fakeDISLPlayerName + '&ACCOUNT_NUMBER=%s' % playerAccountId + '&ACCOUNT_NAME_APPROVAL=%s' % config.GetString('fake-DISL-PlayerNameApproved', 'YES') + '&SWID=%s' % config.GetString('fake-DISL-SWID', '{1763AC36-D73F-41C2-A54A-B579E58B69C8}') + '&FAMILY_NUMBER=%s' % config.GetString('fake-DISL-FamilyAccountId', '-1') + '&familyAdmin=%s' % config.GetString('fake-DISL-FamilyAdmin', '1') + '&PIRATES_ACCESS=%s' % config.GetString('fake-DISL-PiratesAccess', 'FULL') + '&PIRATES_MAX_NUM_AVATARS=%s' % config.GetInt('fake-DISL-MaxAvatars', defaultNumAvatars) + '&PIRATES_NUM_AVATAR_SLOTS=%s' % config.GetInt('fake-DISL-MaxAvatarSlots', defaultNumAvatarSlots) + '&expires=%s' % config.GetString('fake-DISL-expire', '1577898000') + '&OPEN_CHAT_ENABLED=%s' % config.GetString('fake-DISL-OpenChatEnabled', 'YES') + '&CREATE_FRIENDS_WITH_CHAT=%s' % config.GetString('fake-DISL-CreateFriendsWithChat', 'YES') + '&CHAT_CODE_CREATION_RULE=%s' % config.GetString('fake-DISL-ChatCodeCreation', 'YES') + '&FAMILY_MEMBERS=%s' % config.GetString('fake-DISL-FamilyMembers') + '&PIRATES_SUB_COUNT=%s' % subCount
            for i in range(subCount):
                self.DISLToken += '&PIRATES_SUB_%s_ACCESS=%s' % (i, config.GetString('fake-DISL-Sub-%s-Access' % i, 'FULL')) + '&PIRATES_SUB_%s_ACTIVE=%s' % (i, config.GetString('fake-DISL-Sub-%s-Active' % i, 'YES')) + '&PIRATES_SUB_%s_ID=%s' % (i, config.GetInt('fake-DISL-Sub-%s-Id' % i, playerAccountId) + config.GetInt('fake-DISL-Sub-Id-Offset', 0)) + '&PIRATES_SUB_%s_LEVEL=%s' % (i, config.GetInt('fake-DISL-Sub-%s-Level' % i, 3)) + '&PIRATES_SUB_%s_NAME=%s' % (i, config.GetString('fake-DISL-Sub-%s-Name' % i, fakeDISLPlayerName)) + '&PIRATES_SUB_%s_NUM_AVATARS=%s' % (i, config.GetInt('fake-DISL-Sub-%s-NumAvatars' % i, defaultNumAvatars)) + '&PIRATES_SUB_%s_NUM_CONCUR=%s' % (i, config.GetInt('fake-DISL-Sub-%s-NumConcur' % i, defaultNumConcur)) + '&PIRATES_SUB_%s_OWNERID=%s' % (i, config.GetInt('fake-DISL-Sub-%s-OwnerId' % i, playerAccountId)) + '&PIRATES_SUB_%s_FOUNDER=%s' % (i, config.GetString('fake-DISL-Sub-%s-Founder' % i, 'YES'))
            
            self.DISLToken += '&WL_CHAT_ENABLED=%s' % config.GetString('fake-DISL-WLChatEnabled', 'YES') + '&valid=true'
            if base.logPrivateInfo:
                print self.DISLToken
            
        
        self.requiredLogin = config.GetString('required-login', 'auto')
        if self.requiredLogin == 'auto':
            self.notify.info('required-login auto.')
        elif self.requiredLogin == 'green':
            self.notify.error('The green code is out of date')
        elif self.requiredLogin == 'blue':
            if not (self.blue):
                self.notify.error('The tcr does not have the required blue login')
            
        elif self.requiredLogin == 'playToken':
            if not (self.playToken):
                self.notify.error('The tcr does not have the required playToken login')
            
        elif self.requiredLogin == 'DISLToken':
            if not (self.DISLToken):
                self.notify.error('The tcr does not have the required DISL token login')
            
        elif self.requiredLogin == 'gameServer':
            self.notify.info('Using game server name/password.')
            self.DISLToken = None
        else:
            self.notify.error('The required-login was not recognized.')
        self.computeValidateDownload()
        self.wantMagicWords = base.config.GetString('want-magic-words', '')
        if self.launcher and hasattr(self.launcher, 'http'):
            self.http = self.launcher.http
        else:
            self.http = HTTPClient()
        self.allocateDcFile()
        self.accountOldAuth = config.GetBool('account-old-auth', 0)
        self.accountOldAuth = config.GetBool('%s-account-old-auth' % game.name, self.accountOldAuth)
        self.useNewTTDevLogin = base.config.GetBool('use-tt-specific-dev-login', False)
        if self.useNewTTDevLogin:
            self.loginInterface = LoginTTSpecificDevAccount.LoginTTSpecificDevAccount(self)
            self.notify.info('loginInterface: LoginTTSpecificDevAccount')
        elif self.accountOldAuth:
            self.loginInterface = LoginGSAccount.LoginGSAccount(self)
            self.notify.info('loginInterface: LoginGSAccount')
        elif self.blue:
            self.loginInterface = LoginGoAccount.LoginGoAccount(self)
            self.notify.info('loginInterface: LoginGoAccount')
        elif self.playToken:
            self.loginInterface = LoginWebPlayTokenAccount(self)
            self.notify.info('loginInterface: LoginWebPlayTokenAccount')
        elif self.DISLToken:
            self.loginInterface = LoginDISLTokenAccount(self)
            self.notify.info('loginInterface: LoginDISLTokenAccount')
        else:
            self.loginInterface = LoginTTAccount.LoginTTAccount(self)
            self.notify.info('loginInterface: LoginTTAccount')
        self.secretChatAllowed = base.config.GetBool('allow-secret-chat', 0)
        self.openChatAllowed = base.config.GetBool('allow-open-chat', 0)
        if base.config.GetBool('secret-chat-needs-parent-password', 0) and self.launcher:
            pass
        self.secretChatNeedsParentPassword = self.launcher.getNeedPwForSecretKey()
        if base.config.GetBool('parent-password-set', 0) and self.launcher:
            pass
        self.parentPasswordSet = self.launcher.getParentPasswordSet()
        self.userSignature = base.config.GetString('signature', 'none')
        self.freeTimeExpiresAt = -1
        self._OTPClientRepository__isPaid = 1
        self.periodTimerExpired = 0
        self.periodTimerStarted = None
        self.periodTimerSecondsRemaining = None
        self.parentMgr.registerParent(OTPGlobals.SPRender, base.render)
        self.parentMgr.registerParent(OTPGlobals.SPHidden, NodePath())
        self.timeManager = None
        if config.GetBool('detect-leaks', 0) or config.GetBool('client-detect-leaks', 0):
            self.startLeakDetector()
        
        if config.GetBool('detect-messenger-leaks', 0) or config.GetBool('ai-detect-messenger-leaks', 0):
            self.messengerLeakDetector = MessengerLeakDetector.MessengerLeakDetector('client messenger leak detector')
            if config.GetBool('leak-messages', 0):
                MessengerLeakDetector._leakMessengerObject()
            
        
        if config.GetBool('run-garbage-reports', 0) or config.GetBool('client-run-garbage-reports', 0):
            noneValue = -1.0
            reportWait = config.GetFloat('garbage-report-wait', noneValue)
            reportWaitScale = config.GetFloat('garbage-report-wait-scale', noneValue)
            if reportWait == noneValue:
                reportWait = 60.0 * 2.0
            
            if reportWaitScale == noneValue:
                reportWaitScale = None
            
            self.garbageReportScheduler = GarbageReportScheduler(waitBetween = reportWait, waitScale = reportWaitScale)
        
        if not config.GetBool('proactive-leak-checks', 1):
            pass
        self._proactiveLeakChecks = config.GetBool('client-proactive-leak-checks', 1)
        self._crashOnProactiveLeakDetect = config.GetBool('crash-on-proactive-leak-detect', 1)
        self.activeDistrictMap = { }
        self.serverVersion = serverVersion
        self.waitingForDatabase = None
        self.loginFSM = ClassicFSM('loginFSM', [
            State('loginOff', self.enterLoginOff, self.exitLoginOff, [
                'connect']),
            State('connect', self.enterConnect, self.exitConnect, [
                'login',
                'failedToConnect',
                'failedToGetServerConstants']),
            State('login', self.enterLogin, self.exitLogin, [
                'noConnection',
                'waitForGameList',
                'createAccount',
                'reject',
                'failedToConnect',
                'shutdown']),
            State('createAccount', self.enterCreateAccount, self.exitCreateAccount, [
                'noConnection',
                'waitForGameList',
                'login',
                'reject',
                'failedToConnect',
                'shutdown']),
            State('failedToConnect', self.enterFailedToConnect, self.exitFailedToConnect, [
                'connect',
                'shutdown']),
            State('failedToGetServerConstants', self.enterFailedToGetServerConstants, self.exitFailedToGetServerConstants, [
                'connect',
                'shutdown',
                'noConnection']),
            State('shutdown', self.enterShutdown, self.exitShutdown, [
                'loginOff']),
            State('waitForGameList', self.enterWaitForGameList, self.exitWaitForGameList, [
                'noConnection',
                'waitForShardList',
                'missingGameRootObject']),
            State('missingGameRootObject', self.enterMissingGameRootObject, self.exitMissingGameRootObject, [
                'waitForGameList',
                'shutdown']),
            State('waitForShardList', self.enterWaitForShardList, self.exitWaitForShardList, [
                'noConnection',
                'waitForAvatarList',
                'noShards']),
            State('noShards', self.enterNoShards, self.exitNoShards, [
                'noConnection',
                'noShardsWait',
                'shutdown']),
            State('noShardsWait', self.enterNoShardsWait, self.exitNoShardsWait, [
                'noConnection',
                'waitForShardList',
                'shutdown']),
            State('reject', self.enterReject, self.exitReject, []),
            State('noConnection', self.enterNoConnection, self.exitNoConnection, [
                'login',
                'connect',
                'shutdown']),
            State('afkTimeout', self.enterAfkTimeout, self.exitAfkTimeout, [
                'waitForAvatarList',
                'shutdown']),
            State('periodTimeout', self.enterPeriodTimeout, self.exitPeriodTimeout, [
                'shutdown']),
            State('waitForAvatarList', self.enterWaitForAvatarList, self.exitWaitForAvatarList, [
                'noConnection',
                'chooseAvatar',
                'shutdown']),
            State('chooseAvatar', self.enterChooseAvatar, self.exitChooseAvatar, [
                'noConnection',
                'createAvatar',
                'waitForAvatarList',
                'waitForSetAvatarResponse',
                'waitForDeleteAvatarResponse',
                'shutdown',
                'login']),
            State('createAvatar', self.enterCreateAvatar, self.exitCreateAvatar, [
                'noConnection',
                'chooseAvatar',
                'waitForSetAvatarResponse',
                'shutdown']),
            State('waitForDeleteAvatarResponse', self.enterWaitForDeleteAvatarResponse, self.exitWaitForDeleteAvatarResponse, [
                'noConnection',
                'chooseAvatar',
                'shutdown']),
            State('rejectRemoveAvatar', self.enterRejectRemoveAvatar, self.exitRejectRemoveAvatar, [
                'noConnection',
                'chooseAvatar',
                'shutdown']),
            State('waitForSetAvatarResponse', self.enterWaitForSetAvatarResponse, self.exitWaitForSetAvatarResponse, [
                'noConnection',
                'playingGame',
                'shutdown']),
            State('playingGame', self.enterPlayingGame, self.exitPlayingGame, [
                'noConnection',
                'waitForAvatarList',
                'login',
                'shutdown',
                'afkTimeout',
                'periodTimeout',
                'noShards'])], 'loginOff', 'loginOff')
        self.gameFSM = ClassicFSM('gameFSM', [
            State('gameOff', self.enterGameOff, self.exitGameOff, [
                'waitOnEnterResponses']),
            State('waitOnEnterResponses', self.enterWaitOnEnterResponses, self.exitWaitOnEnterResponses, [
                'playGame',
                'tutorialQuestion',
                'gameOff']),
            State('tutorialQuestion', self.enterTutorialQuestion, self.exitTutorialQuestion, [
                'playGame',
                'gameOff']),
            State('playGame', self.enterPlayGame, self.exitPlayGame, [
                'gameOff',
                'closeShard',
                'switchShards']),
            State('switchShards', self.enterSwitchShards, self.exitSwitchShards, [
                'gameOff',
                'waitOnEnterResponses']),
            State('closeShard', self.enterCloseShard, self.exitCloseShard, [
                'gameOff',
                'waitOnEnterResponses'])], 'gameOff', 'gameOff')
        self.loginFSM.getStateNamed('playingGame').addChild(self.gameFSM)
        self.loginFSM.enterInitialState()
        self.loginScreen = None
        self.music = None
        self.gameDoneEvent = 'playGameDone'
        self.playGame = playGame(self.gameFSM, self.gameDoneEvent)
        self.shardListHandle = None
        self.uberZoneInterest = None
        self.wantSwitchboard = config.GetBool('want-switchboard', 0)
        self.wantSwitchboardHacks = base.config.GetBool('want-switchboard-hacks', 0)
        self.centralLogger = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_CENTRAL_LOGGER, 'CentralLogger')
        self.csm = None
    
    def startLeakDetector(self):
        if hasattr(self, 'leakDetector'):
            return False
        
        firstCheckDelay = config.GetFloat('leak-detector-first-check-delay', 2 * 60.0)
        self.leakDetector = ContainerLeakDetector('client container leak detector', firstCheckDelay = firstCheckDelay)
        self.objectTypesLeakDetector = LeakDetectors.ObjectTypesLeakDetector()
        self.garbageLeakDetector = LeakDetectors.GarbageLeakDetector()
        self.renderLeakDetector = LeakDetectors.SceneGraphLeakDetector(render)
        self.hiddenLeakDetector = LeakDetectors.SceneGraphLeakDetector(hidden)
        self.cppMemoryUsageLeakDetector = LeakDetectors.CppMemoryUsage()
        self.taskLeakDetector = LeakDetectors.TaskLeakDetector()
        self.messageListenerTypesLeakDetector = LeakDetectors.MessageListenerTypesLeakDetector()
        return True

    
    def getGameDoId(self):
        return self.GameGlobalsId

    
    def enterLoginOff(self):
        self.handler = self.handleMessageType
        self.shardListHandle = None

    enterLoginOff = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterLoginOff)
    
    def exitLoginOff(self):
        self.handler = None

    exitLoginOff = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitLoginOff)
    
    def computeValidateDownload(self):
        if self.launcher:
            hash = HashVal()
            hash.mergeWith(launcher.launcherFileDbHash)
            hash.mergeWith(launcher.serverDbFileHash)
            self.validateDownload = hash.asHex()
        else:
            self.validateDownload = ''
            if not os.path.expandvars('$TOONTOWN'):
                pass
            basePath = './toontown'
            downloadParFilename = Filename.expandFrom(basePath + '/src/configfiles/download.par')
            if downloadParFilename.exists():
                downloadPar = open(downloadParFilename.toOsSpecific())
                for line in downloadPar.readlines():
                    i = string.find(line, 'VALIDATE_DOWNLOAD=')
                    if i != -1:
                        self.validateDownload = string.strip(line[i + 18:])
                        break
                        continue
                
            

    
    def getServerVersion(self):
        return self.serverVersion

    
    def enterConnect(self, serverList):
        self.serverList = serverList
        dialogClass = OTPGlobals.getGlobalDialogClass()
        self.connectingBox = dialogClass(message = OTPLocalizer.CRConnecting)
        self.connectingBox.show()
        self.renderFrame()
        self.handler = self.handleConnecting
        self.connect(self.serverList, successCallback = self._handleConnected, failureCallback = self.failedToConnect)

    enterConnect = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterConnect)
    
    def failedToConnect(self, statusCode, statusString):
        self.loginFSM.request('failedToConnect', [
            statusCode,
            statusString])

    failedToConnect = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(failedToConnect)
    
    def exitConnect(self):
        self.connectingBox.cleanup()
        del self.connectingBox

    exitConnect = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitConnect)
    
    def handleSystemMessage(self, di):
        message = ClientRepositoryBase.handleSystemMessage(self, di)
        whisper = WhisperPopup(message, OTPGlobals.getInterfaceFont(), WhisperPopup.WTSystem)
        whisper.manage(base.marginManager)
        if not self.systemMessageSfx:
            self.systemMessageSfx = base.loadSfx('phase_3/audio/sfx/clock03.mp3')
        
        if self.systemMessageSfx:
            base.playSfx(self.systemMessageSfx)
        

    
    def getConnectedEvent(self):
        return 'OTPClientRepository-connected'

    
    def _handleConnected(self):
        self.launcher.setDisconnectDetailsNormal()
        messenger.send(self.getConnectedEvent())
        self._sendClientHello()

    _handleConnected = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(_handleConnected)

    def _sendClientHello(self):
        datagram = PyDatagram()
        datagram.addUint16(CLIENT_HELLO)
        datagram.addUint32(0xDEADBEEF) #(self.hashVal) #Skipps: dclass hash val issue.
        datagram.addString(self.serverVersion)
        self.send(datagram)

    _sendClientHello = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(_sendClientHello)

    def handleConnecting(self, msgtype, di):
        if msgtype == CLIENT_HELLO_RESP:
            self.loginFSM.request('login')
            self.handler = None
            self.startReaderPollTask()
        else:
            self.handleMessageType(msgtype, di)
    
    def gotoFirstScreen(self):
        """This possibly could come in handy."""
        
        if base.config.GetBool('want-account-server', False):
            try:
                self.accountServerConstants = AccountServerConstants.AccountServerConstants(self)
            except TTAccount.TTAccountException:
                e = None
                self.notify.debug(str(e))
                self.loginFSM.request('failedToGetServerConstants', [
                    e])
                return None

        self.startReaderPollTask()
        self.startHeartbeat()
        newInstall = launcher.getIsNewInstallation()
        newInstall = base.config.GetBool('new-installation', newInstall)
        if newInstall:
            self.notify.warning('new installation')
        
        self.loginFSM.request('login')

    
    def enterLogin(self):
        self.sendSetAvatarIdMsg(0)
        self.loginDoneEvent = 'loginDone'
        self.accept(self.loginDoneEvent, self.__handleLoginDone)
        self.csm.performLogin(self.loginDoneEvent)
        self.waitForDatabaseTimeout(requestName='WaitOnCSMLoginResponse')

    enterLogin = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterLogin)
    
    def __handleLoginDone(self, doneStatus):
        mode = doneStatus['mode']
        if mode == 'success':
            self.setIsNotNewInstallation()
            self.loginFSM.request('waitForGameList')
        elif mode == 'getChatPassword':
            self.loginFSM.request('parentPassword')
        elif mode == 'freeTimeExpired':
            self.loginFSM.request('freeTimeInform')
        elif mode == 'createAccount':
            self.loginFSM.request('createAccount', [
                {
                    'back': 'login',
                    'backArgs': [] }])
        elif mode == 'reject':
            self.loginFSM.request('reject')
        elif mode == 'quit':
            self.loginFSM.request('shutdown')
        elif mode == 'failure':
            self.loginFSM.request('failedToConnect', [
                -1,
                '?'])
        else:
            self.notify.error('Invalid doneStatus mode from loginScreen: ' + str(mode))

    _OTPClientRepository__handleLoginDone = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(__handleLoginDone)
    
    def exitLogin(self):
        if self.loginScreen:
            self.loginScreen.exit()
            self.loginScreen.unload()
            self.loginScreen = None
            self.renderFrame()
        
        self.ignore(self.loginDoneEvent)
        del self.loginDoneEvent
        self.handler = None

    exitLogin = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitLogin)
    
    def enterCreateAccount(self, createAccountDoneData = {
        'back': 'login',
        'backArgs': [] }):
        self.createAccountDoneData = createAccountDoneData
        self.createAccountDoneEvent = 'createAccountDone'
        self.createAccountScreen = None
        self.createAccountScreen = CreateAccountScreen(self, self.createAccountDoneEvent)
        self.accept(self.createAccountDoneEvent, self._OTPClientRepository__handleCreateAccountDone)
        self.createAccountScreen.load()
        self.createAccountScreen.enter()

    enterCreateAccount = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterCreateAccount)
    
    def __handleCreateAccountDone(self, doneStatus):
        mode = doneStatus['mode']
        if mode == 'success':
            self.setIsNotNewInstallation()
            self.loginFSM.request('waitForGameList')
        elif mode == 'reject':
            self.loginFSM.request('reject')
        elif mode == 'cancel':
            self.loginFSM.request(self.createAccountDoneData['back'], self.createAccountDoneData['backArgs'])
        elif mode == 'failure':
            self.loginFSM.request(self.createAccountDoneData['back'], self.createAccountDoneData['backArgs'])
        elif mode == 'quit':
            self.loginFSM.request('shutdown')
        else:
            self.notify.error('Invalid doneStatus mode from CreateAccountScreen: ' + str(mode))

    _OTPClientRepository__handleCreateAccountDone = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(__handleCreateAccountDone)
    
    def exitCreateAccount(self):
        if self.createAccountScreen:
            self.createAccountScreen.exit()
            self.createAccountScreen.unload()
            self.createAccountScreen = None
            self.renderFrame()
        
        self.ignore(self.createAccountDoneEvent)
        del self.createAccountDoneEvent
        self.handler = None

    exitCreateAccount = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitCreateAccount)
    
    def enterFailedToConnect(self, statusCode, statusString):
        self.handler = self.handleMessageType
        messenger.send('connectionIssue')
        url = self.serverList[0]
        self.notify.warning('Failed to connect to %s (%s %s).  Notifying user.' % (url.cStr(), statusCode, statusString))
        if statusCode == 1403 and statusCode == 1405 or statusCode == 1400:
            message = OTPLocalizer.CRNoConnectProxyNoPort % (url.getServer(), url.getPort(), url.getPort())
            style = OTPDialog.CancelOnly
        else:
            message = OTPLocalizer.CRNoConnectTryAgain % (url.getServer(), url.getPort())
            style = OTPDialog.TwoChoice
        dialogClass = OTPGlobals.getGlobalDialogClass()
        self.failedToConnectBox = dialogClass(message = message, doneEvent = 'failedToConnectAck', text_wordwrap = 18, style = style)
        self.failedToConnectBox.show()
        self.notify.info(message)
        self.accept('failedToConnectAck', self._OTPClientRepository__handleFailedToConnectAck)

    enterFailedToConnect = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterFailedToConnect)
    
    def __handleFailedToConnectAck(self):
        doneStatus = self.failedToConnectBox.doneStatus
        if doneStatus == 'ok':
            self.loginFSM.request('connect', [
                self.serverList])
            messenger.send('connectionRetrying')
        elif doneStatus == 'cancel':
            self.loginFSM.request('shutdown')
        else:
            self.notify.error('Unrecognized doneStatus: ' + str(doneStatus))

    _OTPClientRepository__handleFailedToConnectAck = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(__handleFailedToConnectAck)
    
    def exitFailedToConnect(self):
        self.handler = None
        self.ignore('failedToConnectAck')
        self.failedToConnectBox.cleanup()
        del self.failedToConnectBox

    exitFailedToConnect = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitFailedToConnect)
    
    def enterFailedToGetServerConstants(self, e):
        self.handler = self.handleMessageType
        messenger.send('connectionIssue')
        url = AccountServerConstants.AccountServerConstants.getServerURL()
        statusCode = 0
        if isinstance(e, HTTPUtil.ConnectionError):
            statusCode = e.statusCode
            self.notify.warning('Got status code %s from connection to %s.' % (statusCode, url.cStr()))
        else:
            self.notify.warning("Didn't get status code from connection to %s." % url.cStr())
        if statusCode == 1403 or statusCode == 1400:
            message = OTPLocalizer.CRServerConstantsProxyNoPort % (url.cStr(), url.getPort())
            style = OTPDialog.CancelOnly
        elif statusCode == 1405:
            message = OTPLocalizer.CRServerConstantsProxyNoCONNECT % url.cStr()
            style = OTPDialog.CancelOnly
        else:
            message = OTPLocalizer.CRServerConstantsTryAgain % url.cStr()
            style = OTPDialog.TwoChoice
        dialogClass = OTPGlobals.getGlobalDialogClass()
        self.failedToGetConstantsBox = dialogClass(message = message, doneEvent = 'failedToGetConstantsAck', text_wordwrap = 18, style = style)
        self.failedToGetConstantsBox.show()
        self.accept('failedToGetConstantsAck', self._OTPClientRepository__handleFailedToGetConstantsAck)
        self.notify.warning('Failed to get account server constants. Notifying user.')

    enterFailedToGetServerConstants = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterFailedToGetServerConstants)
    
    def __handleFailedToGetConstantsAck(self):
        doneStatus = self.failedToGetConstantsBox.doneStatus
        if doneStatus == 'ok':
            self.loginFSM.request('connect', [
                self.serverList])
            messenger.send('connectionRetrying')
        elif doneStatus == 'cancel':
            self.loginFSM.request('shutdown')
        else:
            self.notify.error('Unrecognized doneStatus: ' + str(doneStatus))

    _OTPClientRepository__handleFailedToGetConstantsAck = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(__handleFailedToGetConstantsAck)
    
    def exitFailedToGetServerConstants(self):
        self.handler = None
        self.ignore('failedToGetConstantsAck')
        self.failedToGetConstantsBox.cleanup()
        del self.failedToGetConstantsBox

    exitFailedToGetServerConstants = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitFailedToGetServerConstants)
    
    def enterShutdown(self, errorCode = None):
        self.handler = self.handleMessageType
        self.sendDisconnect()
        self.notify.info('Exiting cleanly')
        base.exitShow(errorCode)

    enterShutdown = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterShutdown)
    
    def exitShutdown(self):
        if hasattr(self, 'garbageWatcher'):
            self.garbageWatcher.destroy()
            del self.garbageWatcher
        
        self.handler = None

    exitShutdown = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitShutdown)
    
    def enterWaitForGameList(self):
        self.gameDoDirectory = self.addTaggedInterest(self.GameGlobalsId, OTP_ZONE_ID_MANAGEMENT, self.ITAG_PERM, 'game directory', event = 'GameList_Complete')
        self.acceptOnce('GameList_Complete', self.waitForGetGameListResponse)

    enterWaitForGameList = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterWaitForGameList)
    
    def waitForGetGameListResponse(self):
        if self.isGameListCorrect():
            if base.config.GetBool('game-server-tests', 0):
                GameServerTestSuite = GameServerTestSuite
                import otp.distributed
                GameServerTestSuite.GameServerTestSuite(self)
            
            self.loginFSM.request('waitForShardList')
        else:
            self.loginFSM.request('missingGameRootObject')

    waitForGetGameListResponse = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(waitForGetGameListResponse)
    
    def isGameListCorrect(self):
        return 1

    isGameListCorrect = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(isGameListCorrect)
    
    def exitWaitForGameList(self):
        self.handler = None

    exitWaitForGameList = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitWaitForGameList)
    
    def enterMissingGameRootObject(self):
        self.notify.warning('missing some game root objects.')
        self.handler = self.handleMessageType
        dialogClass = OTPGlobals.getGlobalDialogClass()
        self.missingGameRootObjectBox = dialogClass(message = OTPLocalizer.CRMissingGameRootObject, doneEvent = 'missingGameRootObjectBoxAck', style = OTPDialog.TwoChoice)
        self.missingGameRootObjectBox.show()
        self.accept('missingGameRootObjectBoxAck', self._OTPClientRepository__handleMissingGameRootObjectAck)

    enterMissingGameRootObject = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterMissingGameRootObject)
    
    def __handleMissingGameRootObjectAck(self):
        doneStatus = self.missingGameRootObjectBox.doneStatus
        if doneStatus == 'ok':
            self.loginFSM.request('waitForGameList')
        elif doneStatus == 'cancel':
            self.loginFSM.request('shutdown')
        else:
            self.notify.error('Unrecognized doneStatus: ' + str(doneStatus))

    _OTPClientRepository__handleMissingGameRootObjectAck = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(__handleMissingGameRootObjectAck)
    
    def exitMissingGameRootObject(self):
        self.handler = None
        self.ignore('missingGameRootObjectBoxAck')
        self.missingGameRootObjectBox.cleanup()
        del self.missingGameRootObjectBox

    exitMissingGameRootObject = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitMissingGameRootObject)
    
    def enterWaitForShardList(self):
        if not self.isValidInterestHandle(self.shardListHandle):
            self.shardListHandle = self.addTaggedInterest(self.GameGlobalsId, OTP_ZONE_ID_DISTRICTS, self.ITAG_PERM, 'LocalShardList', event = 'ShardList_Complete')
            self.acceptOnce('ShardList_Complete', self._wantShardListComplete)
        else:
            self._wantShardListComplete()

    enterWaitForShardList = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterWaitForShardList)
    
    def _wantShardListComplete(self):
        if self._shardsAreReady():
            self.loginFSM.request('waitForAvatarList')
        else:
            self.loginFSM.request('noShards')

    _wantShardListComplete = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(_wantShardListComplete)
    
    def _shardsAreReady(self):
        for shard in self.activeDistrictMap.values():
            if shard.available:
                return True
                continue
        else:
            return False

    _shardsAreReady = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(_shardsAreReady)
    
    def exitWaitForShardList(self):
        self.ignore('ShardList_Complete')
        self.handler = None

    exitWaitForShardList = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitWaitForShardList)
    
    def enterNoShards(self):
        messenger.send('connectionIssue')
        self.handler = self.handleMessageType
        dialogClass = OTPGlobals.getGlobalDialogClass()
        self.noShardsBox = dialogClass(message = OTPLocalizer.CRNoDistrictsTryAgain, doneEvent = 'noShardsAck', style = OTPDialog.TwoChoice)
        self.noShardsBox.show()
        self.accept('noShardsAck', self._OTPClientRepository__handleNoShardsAck)

    enterNoShards = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterNoShards)
    
    def __handleNoShardsAck(self):
        doneStatus = self.noShardsBox.doneStatus
        if doneStatus == 'ok':
            messenger.send('connectionRetrying')
            self.loginFSM.request('noShardsWait')
        elif doneStatus == 'cancel':
            self.loginFSM.request('shutdown')
        else:
            self.notify.error('Unrecognized doneStatus: ' + str(doneStatus))

    _OTPClientRepository__handleNoShardsAck = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(__handleNoShardsAck)
    
    def exitNoShards(self):
        self.handler = None
        self.ignore('noShardsAck')
        self.noShardsBox.cleanup()
        del self.noShardsBox

    exitNoShards = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitNoShards)
    
    def enterNoShardsWait(self):
        dialogClass = OTPGlobals.getGlobalDialogClass()
        self.connectingBox = dialogClass(message = OTPLocalizer.CRConnecting)
        self.connectingBox.show()
        self.renderFrame()
        self.noShardsWaitTaskName = 'noShardsWait'
        
        def doneWait(task, self = self):
            self.loginFSM.request('waitForShardList')

        if __dev__:
            delay = 0.0
        else:
            delay = 6.5 + random.random() * 2.0
        taskMgr.doMethodLater(delay, doneWait, self.noShardsWaitTaskName)

    enterNoShardsWait = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterNoShardsWait)
    
    def exitNoShardsWait(self):
        taskMgr.remove(self.noShardsWaitTaskName)
        del self.noShardsWaitTaskName
        self.connectingBox.cleanup()
        del self.connectingBox

    exitNoShardsWait = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitNoShardsWait)
    
    def enterReject(self):
        self.handler = self.handleMessageType
        self.notify.warning('Connection Rejected')
        launcher.setPandaErrorCode(13)
        sys.exit()

    enterReject = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterReject)
    
    def exitReject(self):
        self.handler = None

    exitReject = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitReject)
    
    def enterNoConnection(self):
        messenger.send('connectionIssue')
        self.resetInterestStateForConnectionLoss()
        self.shardListHandle = None
        self.handler = self.handleMessageType
        self._OTPClientRepository__currentAvId = 0
        self.stopHeartbeat()
        self.stopReaderPollTask()
        gameUsername = self.playToken
        if self.bootedIndex != None and OTPLocalizer.CRBootedReasons.has_key(self.bootedIndex):
            message = OTPLocalizer.CRBootedReasons[self.bootedIndex] % {
                'name': gameUsername }
        elif self.bootedText != None:
            message = OTPLocalizer.CRBootedReasonUnknownCode % self.bootedIndex
        else:
            message = OTPLocalizer.CRLostConnection
        reconnect = 1
        if self.bootedIndex in (152, 127):
            reconnect = 0
        
        self.launcher.setDisconnectDetails(self.bootedIndex, message)
        style = OTPDialog.Acknowledge
        if reconnect and self.loginInterface.supportsRelogin():
            message += OTPLocalizer.CRTryConnectAgain
            style = OTPDialog.TwoChoice
        
        dialogClass = OTPGlobals.getGlobalDialogClass()
        self.lostConnectionBox = dialogClass(doneEvent = 'lostConnectionAck', message = message, text_wordwrap = 18, style = style)
        self.lostConnectionBox.show()
        self.accept('lostConnectionAck', self._OTPClientRepository__handleLostConnectionAck)
        self.notify.warning('Lost connection to server. Notifying user.')

    enterNoConnection = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterNoConnection)
    
    def __handleLostConnectionAck(self):
        if self.lostConnectionBox.doneStatus == 'ok' and self.loginInterface.supportsRelogin():
            self.loginFSM.request('connect', [
                self.serverList])
        else:
            self.loginFSM.request('shutdown')

    _OTPClientRepository__handleLostConnectionAck = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(__handleLostConnectionAck)
    
    def exitNoConnection(self):
        self.handler = None
        self.ignore('lostConnectionAck')
        self.lostConnectionBox.cleanup()
        messenger.send('connectionRetrying')

    exitNoConnection = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(exitNoConnection)
    
    def enterAfkTimeout(self):
        self.sendSetAvatarIdMsg(0)
        msg = OTPLocalizer.AfkForceAcknowledgeMessage
        dialogClass = OTPGlobals.getDialogClass()
        self.afkDialog = dialogClass(text = msg, command = self._OTPClientRepository__handleAfkOk, style = OTPDialog.Acknowledge)
        self.handler = self.handleMessageType

    enterAfkTimeout = report(types = [
        'args',
        'deltaStamp'], dConfigParam = 'teleport')(enterAfkTimeout)
    
    def __handleAfkOk(self, value):
        self.loginFSM.request('waitForAvatarList')