def __init__(self, forGui = 0):
Avatar.Avatar.__init__(self)
self.serialNum = Pet.SerialNum
Pet.SerialNum += 1
self.lockedDown = 0
self.setPickable(1)
self.setPlayerType(NametagGroup.CCNonPlayer)
self.animFSM = ClassicFSM('petAnimFSM', [State('off', self.enterOff, self.exitOff),
State('neutral', self.enterNeutral, self.exitNeutral),
State('neutralHappy', self.enterNeutralHappy, self.exitNeutralHappy),
State('neutralSad', self.enterNeutralSad, self.exitNeutralSad),
State('run', self.enterRun, self.exitRun),
State('swim', self.enterSwim, self.exitSwim),
State('teleportIn', self.enterTeleportIn, self.exitTeleportOut),
State('teleportOut', self.enterTeleportOut, self.exitTeleportOut),
State('walk', self.enterWalk, self.exitWalk),
State('walkHappy', self.enterWalkHappy, self.exitWalkHappy),
State('walkSad', self.enterWalkSad, self.exitWalkSad)], 'off', 'off')
self.animFSM.enterInitialState()
self.forGui = forGui
self.moodModel = None
self.__blinkName = 'petblink-' + str(self.this)
self.track = None
self.soundBackflip = None
self.soundRollover = None
self.soundPlaydead = None
self.soundTeleportIn = None
self.soundTeleportOut = None
self.teleportHole = None
return
def __init__(self, parentFSM, doneEvent, dnaStore, hoodId):
Hood.Hood.__init__(self, parentFSM, doneEvent, dnaStore, hoodId)
self.suitInteriorDoneEvent = 'suitInteriorDone'
self.minigameDoneEvent = 'minigameDone'
self.safeZoneLoaderClass = None
self.townLoaderClass = None
self.fsm = ClassicFSM.ClassicFSM('Hood', [
State.State('start', self.enterStart, self.exitStart,
['townLoader', 'safeZoneLoader']),
State.State('townLoader', self.enterTownLoader,
self.exitTownLoader, [
'quietZone', 'safeZoneLoader', 'suitInterior',
'cogdoInterior'
]),
State.State('safeZoneLoader', self.enterSafeZoneLoader,
self.exitSafeZoneLoader, [
'quietZone', 'suitInterior', 'cogdoInterior',
'townLoader', 'minigame'
]),
State.State('purchase', self.enterPurchase, self.exitPurchase,
['quietZone', 'minigame', 'safeZoneLoader']),
State.State('suitInterior', self.enterSuitInterior,
self.exitSuitInterior,
['quietZone', 'townLoader', 'safeZoneLoader']),
State.State('cogdoInterior', self.enterCogdoInterior,
self.exitCogdoInterior,
['quietZone', 'townLoader', 'safeZoneLoader']),
State.State('minigame', self.enterMinigame, self.exitMinigame,
['purchase']),
State.State('quietZone', self.enterQuietZone, self.exitQuietZone, [
'safeZoneLoader', 'townLoader', 'suitInterior',
'cogdoInterior', 'minigame'
]),
State.State('final', self.enterFinal, self.exitFinal, [])
], 'start', 'final')
self.fsm.enterInitialState()
def __init__(self, air):
DistributedCCharBaseAI.DistributedCCharBaseAI.__init__(
self, air, TTLocalizer.Chip)
self.fsm = ClassicFSM.ClassicFSM(
'DistributedChipAI',
[
State.State('Off', self.enterOff, self.exitOff, ['Lonely']),
State.State('Lonely', self.enterLonely, self.exitLonely,
['Chatty', 'Walk']),
State.State('Chatty', self.enterChatty, self.exitChatty,
['Lonely', 'Walk']),
State.State('Walk', self.enterWalk, self.exitWalk,
['Lonely', 'Chatty']),
],
# Initial State
'Off',
# Final State
'Off',
)
self.fsm.enterInitialState()
self.dale = None
self.handleHolidays()
def __init__(self, hood, parentFSMState, doneEvent):
StateData.StateData.__init__(self, doneEvent)
self.hood = hood
self.parentFSMState = parentFSMState
self.fsm = ClassicFSM.ClassicFSM('SafeZoneLoader', [
State.State('start', self.enterStart, self.exitStart, [
'quietZone',
'playground',
'toonInterior']),
State.State('playground', self.enterPlayground, self.exitPlayground, [
'quietZone']),
State.State('toonInterior', self.enterToonInterior, self.exitToonInterior, [
'quietZone']),
State.State('quietZone', self.enterQuietZone, self.exitQuietZone, [
'playground',
'toonInterior']),
State.State('golfcourse', self.enterGolfcourse, self.exitGolfcourse, [
'quietZone',
'playground']),
State.State('final', self.enterFinal, self.exitFinal, [
'start'])], 'start', 'final')
self.placeDoneEvent = 'placeDone'
self.place = None
self.playgroundClass = None
def __init__(self, parentFSM, doneEvent, dnaStore, hoodId):
Hood.Hood.__init__(self, parentFSM, doneEvent, dnaStore, hoodId)
self.fsm = ClassicFSM.ClassicFSM('Hood', [
State.State('start', self.enterStart, self.exitStart,
['safeZoneLoader']),
State.State('safeZoneLoader', self.enterSafeZoneLoader,
self.exitSafeZoneLoader, ['quietZone']),
State.State('quietZone', self.enterQuietZone, self.exitQuietZone,
['safeZoneLoader']),
State.State('final', self.enterFinal, self.exitFinal, [])
], 'start', 'final')
self.fsm.enterInitialState()
self.id = PartyHood
self.safeZoneLoaderClass = PartyLoader.PartyLoader
self.partyActivityDoneEvent = 'partyActivityDone'
self.storageDNAFile = 'phase_13/dna/storage_party_sz.dna'
self.holidayStorageDNADict = {
WINTER_DECORATIONS: ['phase_5.5/dna/winter_storage_estate.dna'],
WACKY_WINTER_DECORATIONS:
['phase_5.5/dna/winter_storage_estate.dna']
}
self.skyFile = 'phase_3.5/models/props/TT_sky'
self.popupInfo = None
return
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
self.tableModelPath = 'phase_6/models/golf/game_table.bam'
self.numSeats = 6
self.__toonTracks = {}
self.gameMenu = None
self.game = None
self.gameDoId = 0
self.timerFunc = None
self.gameWantTimer = False
self.cameraBoardTrack = None
self.tutorial = None
self.fsm = ClassicFSM.ClassicFSM('DistributedGameTable', [
State.State('off', self.enterOff, self.exitOff,
['chooseMode', 'observing']),
State.State('chooseMode', self.enterChooseMode,
self.exitChooseMode, ['sitting', 'off', 'observing']),
State.State('sitting', self.enterSitting, self.exitSitting,
['off']),
State.State('observing', self.enterObserving, self.exitObserving,
['off'])
], 'off', 'off')
self.fsm.enterInitialState()
def __init__(self, path=None):
if path is not None:
if path in MintRoomSpecs.CashbotMintConnectorRooms:
loadFunc = loader.loadModelCopy
else:
loadFunc = loader.loadModel
self.setGeom(loadFunc(path))
self.localToonFSM = ClassicFSM.ClassicFSM(
'MintRoomLocalToonPresent',
[
State.State('off', self.enterLtOff, self.exitLtOff,
['notPresent']),
State.State('notPresent', self.enterLtNotPresent,
self.exitLtNotPresent, ['present']),
State.State('present', self.enterLtPresent, self.exitLtPresent,
['notPresent']),
],
# Initial State
'notPresent',
# Final State
'notPresent',
)
self.localToonFSM.enterInitialState()
def __init__(self, safeZone, parentFSM, doneEvent):
StateData.StateData.__init__(self, doneEvent)
self.fsm = ClassicFSM.ClassicFSM('Trolley', [
State.State('start', self.enterStart, self.exitStart,
['requestBoard', 'trolleyHFA', 'trolleyTFA']),
State.State('trolleyHFA', self.enterTrolleyHFA,
self.exitTrolleyHFA, ['final']),
State.State('trolleyTFA', self.enterTrolleyTFA,
self.exitTrolleyTFA, ['final']),
State.State('requestBoard', self.enterRequestBoard,
self.exitRequestBoard, ['boarding']),
State.State('boarding', self.enterBoarding, self.exitBoarding,
['boarded']),
State.State('boarded', self.enterBoarded, self.exitBoarded,
['requestExit', 'trolleyLeaving', 'final']),
State.State('requestExit', self.enterRequestExit,
self.exitRequestExit, ['exiting', 'trolleyLeaving']),
State.State('trolleyLeaving', self.enterTrolleyLeaving,
self.exitTrolleyLeaving, ['final']),
State.State('exiting', self.enterExiting, self.exitExiting,
['final']),
State.State('final', self.enterFinal, self.exitFinal, ['start'])
], 'start', 'final')
self.parentFSM = parentFSM
def __init__(self, air, chipId):
DistributedCCharBaseAI.DistributedCCharBaseAI.__init__(self, air, TTLocalizer.Dale)
self.chipId = chipId
self.chip = air.doId2do.get(chipId)
self.fsm = ClassicFSM.ClassicFSM('DistributedDaleAI', [
State.State('Off', self.enterOff, self.exitOff, [
'Lonely']),
State.State('Lonely', self.enterLonely, self.exitLonely, [
'Chatty',
'FollowChip',
'Walk']),
State.State('Chatty', self.enterChatty, self.exitChatty, [
'Lonely',
'FollowChip',
'Walk']),
State.State('Walk', self.enterWalk, self.exitWalk, [
'Lonely',
'Chatty']),
State.State('FollowChip', self.enterFollowChip, self.exitFollowChip, [
'Lonely',
'Chatty',
'FollowChip'])], 'Off', 'Off')
self.fsm.enterInitialState()
self.handleHolidays()
def __init__(self, cr):
try:
self.DistributedGoofy_initialized
except:
self.DistributedGoofy_initialized = 1
DistributedCCharBase.DistributedCCharBase.__init__(
self, cr, TTLocalizer.Goofy, 'g')
self.fsm = ClassicFSM.ClassicFSM(
self.getName(),
[
State.State('Off', self.enterOff, self.exitOff,
['Neutral']),
State.State('Neutral', self.enterNeutral, self.exitNeutral,
['Walk']),
State.State('Walk', self.enterWalk, self.exitWalk,
['Neutral']),
],
# Initial State
'Off',
# Final State
'Off',
)
self.fsm.enterInitialState()
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
def __init__(self, cr):
self.flyingEvidenceTrack = None
try:
pass
except:
self.DistributedSuit_initialized = 1
DistributedSuitBase.DistributedSuitBase.__init__(self, cr)
self.activeIntervals = {}
self.boss = None
self.fsm = ClassicFSM.ClassicFSM('DistributedLawbotBossSuit', [
State.State('Off', self.enterOff, self.exitOff,
['Walk', 'Battle', 'neutral']),
State.State('Walk', self.enterWalk, self.exitWalk,
['WaitForBattle', 'Battle']),
State.State('Battle', self.enterBattle, self.exitBattle, []),
State.State(
'neutral', self.enterNeutral, self.exitNeutral,
['PreThrowProsecute', 'PreThrowAttack', 'Stunned']),
State.State('PreThrowProsecute', self.enterPreThrowProsecute,
self.exitPreThrowProsecute,
['PostThrowProsecute', 'neutral', 'Stunned']),
State.State('PostThrowProsecute', self.enterPostThrowProsecute,
self.exitPostThrowProsecute,
['neutral', 'Stunned']),
State.State('PreThrowAttack', self.enterPreThrowAttack,
self.exitPreThrowAttack,
['PostThrowAttack', 'neutral', 'Stunned']),
State.State('PostThrowAttack', self.enterPostThrowAttack,
self.exitPostThrowAttack, ['neutral', 'Stunned']),
State.State('Stunned', self.enterStunned, self.exitStunned,
['neutral']),
State.State('WaitForBattle', self.enterWaitForBattle,
self.exitWaitForBattle, ['Battle'])
], 'Off', 'Off')
self.fsm.enterInitialState()
def __init__(self, cr):
try:
self.DistributedSuit_initialized
except:
self.DistributedSuit_initialized = 1
DistributedSuitBase.DistributedSuitBase.__init__(self, cr)
self.fsm = ClassicFSM.ClassicFSM('DistributedSuit', [State.State('Off', self.enterOff, self.exitOff, ['Walk', 'Battle']),
State.State('Walk', self.enterWalk, self.exitWalk, ['WaitForBattle', 'Battle', 'Chase']),
State.State('Chase', self.enterChase, self.exitChase, ['WaitForBattle', 'Battle', 'Return']),
State.State('Return', self.enterReturn, self.exitReturn, ['WaitForBattle', 'Battle', 'Walk']),
State.State('Battle', self.enterBattle, self.exitBattle, ['Walk', 'Chase', 'Return']),
State.State('WaitForBattle', self.enterWaitForBattle, self.exitWaitForBattle, ['Battle'])], 'Off', 'Off')
self.path = None
self.walkTrack = None
self.chaseTrack = None
self.returnTrack = None
self.fsm.enterInitialState()
self.chasing = 0
self.paused = 0
self.pauseTime = 0
self.velocity = 3
self.factoryRequest = None
return
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
self.eastWestMopath = Mopath.Mopath()
self.westEastMopath = Mopath.Mopath()
self.eastWestMopathInterval = None
self.westEastMopathInterval = None
self.fsm = ClassicFSM.ClassicFSM('DistributedBoat', [
State.State(
'off', self.enterOff, self.exitOff,
['DockedEast', 'SailingWest', 'DockedWest', 'SailingEast']),
State.State('DockedEast', self.enterDockedEast,
self.exitDockedEast,
['SailingWest', 'SailingEast', 'DockedWest']),
State.State('SailingWest', self.enterSailingWest,
self.exitSailingWest,
['DockedWest', 'SailingEast', 'DockedEast']),
State.State('DockedWest', self.enterDockedWest,
self.exitDockedWest,
['SailingEast', 'SailingWest', 'DockedEast']),
State.State('SailingEast', self.enterSailingEast,
self.exitSailingEast,
['DockedEast', 'DockedWest', 'SailingWest'])
], 'off', 'off')
self.fsm.enterInitialState()
def __init__(self, cr):
DistributedMinigame.__init__(self, cr)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedPatternGame', [
State.State('off', self.enterOff, self.exitOff,
['waitForServerPattern']),
State.State('waitForServerPattern', self.enterWaitForServerPattern,
self.exitWaitForServerPattern,
['showServerPattern', 'cleanup']),
State.State('showServerPattern', self.enterShowServerPattern,
self.exitShowServerPattern,
['getUserInput', 'playBackPatterns', 'cleanup']),
State.State(
'getUserInput', self.enterGetUserInput, self.exitGetUserInput,
['waitForPlayerPatterns', 'playBackPatterns', 'cleanup']),
State.State('waitForPlayerPatterns',
self.enterWaitForPlayerPatterns,
self.exitWaitForPlayerPatterns,
['playBackPatterns', 'cleanup', 'checkGameOver']),
State.State('playBackPatterns', self.enterPlayBackPatterns,
self.exitPlayBackPatterns,
['checkGameOver', 'cleanup']),
State.State('checkGameOver', self.enterCheckGameOver,
self.exitCheckGameOver,
['waitForServerPattern', 'cleanup']),
State.State('cleanup', self.enterCleanup, self.exitCleanup, [])
], 'off', 'cleanup')
self.addChildGameFSM(self.gameFSM)
self.arrowColor = VBase4(1, 0, 0, 1)
self.xColor = VBase4(1, 0, 0, 1)
self.celebrate = 0
self.oldBgColor = None
self.trans = VBase4(1, 0, 0, 0)
self.opaq = VBase4(1, 0, 0, 1)
self.normalTextColor = VBase4(0.53700000000000003, 0.83999999999999997,
0.33000000000000002, 1.0)
self._DistributedPatternGame__otherToonIndex = {}
def __init__(self, cr):
DistributedObject.__init__(self, cr)
self.fsm = ClassicFSM.ClassicFSM('TutorialFSM', [
State.State('off', self.enterOff, self.exitOff),
State.State('newPlayerEmerge', self.enterPlayerEmerge,
self.exitPlayerEmerge, ['off', 'introSpeech']),
State.State('introSpeech', self.enterGuideIntroSpeech,
self.exitGuideIntroSpeech,
['off', 'introSpeech2Training']),
State.State('introSpeech2Training', self.enterIntroSpeech2Training,
self.exitIntroSpeech2Training, ['off', 'training1']),
State.State('training1', self.enterTrainingPT1,
self.exitTrainingPT1, ['off', 'training2info']),
State.State('training2info', self.enterTraining2Info,
self.exitTraining2Info, ['off', 'training2']),
State.State('training2', self.enterTrainingPT2,
self.exitTrainingPT2, ['off', 'training3info']),
State.State('training3info', self.enterTraining3Info,
self.exitTraining3Info, ['off', 'training3']),
State.State('training3', self.enterTrainingPT3,
self.exitTrainingPT3, ['off', 'trainingDone']),
State.State('trainingDone', self.enterTrainingDone,
self.exitTrainingDone, ['off', 'leaveTutorial']),
State.State('leaveTutorial', self.enterLeaveTutorial,
self.exitLeaveTutorial, ['off'])
], 'off', 'off')
self.fsm.enterInitialState()
self.dnaStore = DNAStorage()
self.streetGeom = None
self.sky = None
self.skyUtil = SkyUtil()
self.guide = None
self.music = None
self.battleMusic = None
self.playerCamPos = None
self.playerCamHpr = None
def __init__(self, air, suitPlanner):
DistributedSuitBaseAI.DistributedSuitBaseAI.__init__(
self, air, suitPlanner)
self.stunned = False
self.timeToRelease = 3.1499999999999999
self.timeProsecuteStarted = 0
self.fsm = ClassicFSM.ClassicFSM('DistributedLawbotBossSuitAI', [
State.State('Off', self.enterOff, self.exitOff, ['neutral']),
State.State('neutral', self.enterNeutral, self.exitNeutral,
['PreThrowProsecute', 'PreThrowAttack', 'Stunned']),
State.State('PreThrowProsecute', self.enterPreThrowProsecute,
self.exitPreThrowProsecute,
['PostThrowProsecute', 'neutral', 'Stunned']),
State.State('PostThrowProsecute', self.enterPostThrowProsecute,
self.exitPostThrowProsecute, ['neutral', 'Stunned']),
State.State('PreThrowAttack', self.enterPreThrowAttack,
self.exitPreThrowAttack,
['PostThrowAttack', 'neutral', 'Stunned']),
State.State('PostThrowAttack', self.enterPostThrowAttack,
self.exitPostThrowAttack, ['neutral', 'Stunned']),
State.State('Stunned', self.enterStunned, self.exitStunned,
['neutral'])
], 'Off', 'Off')
self.fsm.enterInitialState()
def __init__(self, doneEvent):
StateData.StateData.__init__(self, doneEvent)
self.fsm = ClassicFSM.ClassicFSM('QuietZoneState', [
State.State('off', self.enterOff, self.exitOff,
['waitForQuietZoneResponse']),
State.State(
'waitForQuietZoneResponse', self.enterWaitForQuietZoneResponse,
self.exitWaitForQuietZoneResponse, ['waitForZoneRedirect']),
State.State('waitForZoneRedirect', self.enterWaitForZoneRedirect,
self.exitWaitForZoneRedirect,
['waitForSetZoneResponse']),
State.State(
'waitForSetZoneResponse', self.enterWaitForSetZoneResponse,
self.exitWaitForSetZoneResponse, ['waitForSetZoneComplete']),
State.State('waitForSetZoneComplete',
self.enterWaitForSetZoneComplete,
self.exitWaitForSetZoneComplete,
['waitForLocalAvatarOnShard']),
State.State('waitForLocalAvatarOnShard',
self.enterWaitForLocalAvatarOnShard,
self.exitWaitForLocalAvatarOnShard, ['off'])
], 'off', 'off')
self._enqueueCount = 0
self.fsm.enterInitialState()
def __init__(self, air, minigameId):
try:
pass
except:
self.DistributedVineGameAI_initialized = 1
DistributedMinigameAI.__init__(self, air, minigameId)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedVineGameAI', [
State.State('inactive', self.enterInactive, self.exitInactive,
['play']),
State.State('play', self.enterPlay, self.exitPlay,
['cleanup', 'waitShowScores']),
State.State('waitShowScores', self.enterWaitShowScores,
self.exitWaitShowScores, ['cleanup']),
State.State('cleanup', self.enterCleanup, self.exitCleanup,
['inactive'])
], 'inactive', 'inactive')
self.toonInfo = {}
self.addChildGameFSM(self.gameFSM)
self.vineSections = []
self.finishedBonus = {}
self.finishedTimeLeft = {}
self.totalSpiders = 0
self.calculatedPartialBeans = False
def __init__(self, air):
"""__init__(air)
"""
DistributedObjectAI.DistributedObjectAI.__init__(self, air)
self.seats = [None, None, None, None]
# Flag that tells whether the trolley is currently accepting boarders
self.accepting = 0
self.trolleyCountdownTime = \
ConfigVariableDouble("trolley-countdown-time",
TROLLEY_COUNTDOWN_TIME).getValue()
self.fsm = ClassicFSM.ClassicFSM(
'DistributedTrolleyAI',
[
State.State('off', self.enterOff, self.exitOff, ['entering']),
State.State('entering', self.enterEntering, self.exitEntering,
['waitEmpty']),
State.State('waitEmpty', self.enterWaitEmpty,
self.exitWaitEmpty, ['waitCountdown']),
State.State('waitCountdown', self.enterWaitCountdown,
self.exitWaitCountdown,
['waitEmpty', 'allAboard']),
State.State('allAboard', self.enterAllAboard,
self.exitAllAboard, ['leaving', 'waitEmpty']),
State.State('leaving', self.enterLeaving, self.exitLeaving,
['entering'])
],
# Initial State
'off',
# Final State
'off',
)
self.fsm.enterInitialState()
def __init__(self, air):
DistributedCCharBaseAI.DistributedCCharBaseAI.__init__(
self, air, TTLocalizer.DonaldDock)
self.fsm = ClassicFSM.ClassicFSM(
'DistributedDonaldDockAI',
[
State.State('Off', self.enterOff, self.exitOff,
['Lonely', 'TransitionToCostume']),
State.State('Lonely', self.enterLonely, self.exitLonely,
['Chatty', 'TransitionToCostume']),
State.State('Chatty', self.enterChatty, self.exitChatty,
['Lonely', 'TransitionToCostume']),
State.State('TransitionToCostume',
self.enterTransitionToCostume,
self.exitTransitionToCostume, ['Off']),
],
# Initial State
'Off',
# Final State
'Off',
)
self.fsm.enterInitialState()
self.handleHolidays()
def __init__(self, air, minigameId):
try:
self.DistributedCogThiefGameAI_initialized
except:
self.DistributedCogThiefGameAI_initialized = 1
DistributedMinigameAI.DistributedMinigameAI.__init__(self, air, minigameId)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedCogThiefGameAI',
[
State.State('inactive',
self.enterInactive,
self.exitInactive,
['play']),
State.State('play',
self.enterPlay,
self.exitPlay,
['cleanup']),
State.State('cleanup',
self.enterCleanup,
self.exitCleanup,
['inactive']),
],
# Initial State
'inactive',
# Final State
'inactive',
)
# Add our game ClassicFSM to the framework ClassicFSM
self.addChildGameFSM(self.gameFSM)
self.cogInfo = {}
self.barrelInfo = {}
self.initBarrelInfo()
def __init__(self, air, minigameId):
try:
self.DistributedTargetGameAI_initialized
except:
self.DistributedTargetGameAI_initialized = 1
DistributedMinigameAI.__init__(self, air, minigameId)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedTargetGameAI', [
State.State('inactive', self.enterInactive, self.exitInactive,
['fly']),
State.State('fly', self.enterFly, self.exitFly,
['cleanup', 'resetRound']),
State.State('resetRound', self.enterResetRound,
self.exitResetRound, ['cleanup', 'fly']),
State.State('cleanup', self.enterCleanup, self.exitCleanup,
['inactive'])
], 'inactive', 'inactive')
self.addChildGameFSM(self.gameFSM)
self.__timeBase = globalClockDelta.localToNetworkTime(
globalClock.getRealTime())
self.round = 2
self.barrierScore = None
self.scoreTrack = []
return
def __init__(self, toon):
self.lt = toon
self.doneEvent = "motionDone"
StateData.StateData.__init__(self, self.doneEvent)
# The motionFSM keeps track of whether you are playing the
# run/walk/reverse/stand animation. It is seperate from
# the animFSM states, because you can be in the "happy" or
# "sad" animFSM state and also be running/walking/standing, etc.
# SDN: should this be defined here or somewhere else?
self.fsm = ClassicFSM.ClassicFSM(
'Motion',
[
State.State('off', self.enterOff, self.exitOff),
State.State('neutral', self.enterNeutral, self.exitNeutral),
State.State('walk', self.enterWalk, self.exitWalk),
State.State('run', self.enterRun, self.exitRun),
State.State('sad-neutral', self.enterSadNeutral,
self.exitSadNeutral),
State.State('sad-walk', self.enterSadWalk, self.exitSadWalk),
State.State('catch-neutral', self.enterCatchNeutral,
self.exitCatchNeutral),
State.State('catch-run', self.enterCatchRun,
self.exitCatchRun),
State.State('catch-eatneutral', self.enterCatchEatNeutral,
self.exitCatchEatNeutral),
State.State('catch-eatnrun', self.enterCatchEatNRun,
self.exitCatchEatNRun),
],
# Initial State
'off',
# Final State
'off',
)
self.fsm.enterInitialState()
def __init__(self, air, minigameId):
try:
pass
except:
self.DistributedRaceGameAI_initialized = 1
DistributedMinigameAI.__init__(self, air, minigameId)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedRaceGameAI', [
State.State('inactive', self.enterInactive, self.exitInactive,
['waitClientsChoices']),
State.State('waitClientsChoices', self.enterWaitClientsChoices,
self.exitWaitClientsChoices,
['processChoices', 'cleanup']),
State.State('processChoices', self.enterProcessChoices,
self.exitProcessChoices,
['waitClientsChoices', 'cleanup']),
State.State('cleanup', self.enterCleanup, self.exitCleanup,
['inactive'])
], 'inactive', 'inactive')
self.addChildGameFSM(self.gameFSM)
self.avatarChoices = {}
self.avatarPositions = {}
self.chancePositions = {}
self.rewardDict = {}
def __init__(self, cr):
DistributedNPCToonBase.__init__(self, cr)
self.pickColorGui = None
self.pickColorGuiDoneEvent = 'pickColorGuiDone'
self.nextCollision = 0
self.fsm = ClassicFSM.ClassicFSM(
'NPCYin',
[
State.State('off', self.enterOff, self.exitOff, ['pickColor']),
State.State('pickColor', self.enterPickColor, self.exitPickColor, ['off'])
], 'off', 'off')
self.fsm.enterInitialState()
self.title = None
self.yesButton = None
self.noButton = None
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')
def __init__(self, air, minigameId):
try:
self.DistributedTugOfWarGameAI_initialized
except:
self.DistributedTugOfWarGameAI_initialized = 1
DistributedMinigameAI.__init__(self, air, minigameId)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedTugOfWarGameAI',
[
State.State('off',
self.enterInactive,
self.exitInactive,
['waitClientsReady',
'cleanup']),
State.State('waitClientsReady',
self.enterWaitClientsReady,
self.exitWaitClientsReady,
['sendGoSignal',
'cleanup']),
State.State('sendGoSignal',
self.enterSendGoSignal,
self.exitSendGoSignal,
['waitForResults',
'cleanup']),
State.State('waitForResults',
self.enterWaitForResults,
self.exitWaitForResults,
['waitClientsReady',
'contestOver',
'cleanup']),
State.State('contestOver',
self.enterContestOver,
self.exitContestOver,
['cleanup']),
State.State('cleanup',
self.enterCleanup,
self.exitCleanup,
['off']),
],
# Initial State
'off',
# Final State
'off',
)
# Add our game ClassicFSM to the framework ClassicFSM in the game state
self.addChildGameFSM(self.gameFSM)
self.switched = 0
# Keep track of which side each avatar is on
self.side = {}
# Add up all the players forces for each side as soon as we get a
# keyRate update from all players.
self.forceDict = [{},{}]
self.keyRateDict = {}
self.howManyReported = 0
# The difference between each side's total force (deltaF) is calculated
# and from that an absolute offset (deltaX) from each toons original
# position is calculated. See calculateOffsets function for more info
self.offsetDict = {}
# This constant is multiplied by the force to give the deltaX that the
# toon moves
self.kMovement = .02
# If we are in a Toon vs. Cog game the AI has
# to determine how hard the suit is pulling, and send
# the suit's offset to the clients. The suitForces array
# contains (duration, force) pairs. All the durations should
# at least add up to the length of the game (40 sec).
self.suitId = 666
#self.suitForces = [(6,4), (2,5.5), (2,7.5), (4,8), (4,7), (8,8), (9,8.5), (4,9)]
self.suitForces = [(6,4), (2,5), (2,6.5), (3,8.0), (5,6), (8,8), (9,8.5), (4,9)]
self.suitForceMultiplier = .75
self.curSuitForce = 0
self.suitOffset = 0
# Variables for determining the outcome of the game. If contestEnded=1
# that means someone actually fell in the water. A list of winners,
# losers, and tie-ers are sent to the clients, so the toons can react
# in the correct way (celebrate or sulk). A time bonus is rewarded for
# either winning fast, or losing slow
self.contestEnded = 0
self.losingSide = -1
self.winners = []
self.losers = []
self.tieers = []
self.timeBonus = float(TugOfWarGameGlobals.TIME_BONUS_RANGE)
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
def __init__(self, avId, avName):
SocialPage.SocialPage.__init__(self, 'TradeInviter')
self.initialiseoptions(TradeInviter)
self.avId = avId
self.avName = avName
self.avDisableName = 'disable-%s' % self.avId
self.fsm = ClassicFSM.ClassicFSM('TradeInviter', [
State.State('off', self.enterOff, self.exitOff),
State.State('getNewTrade', self.enterGetNewTrade, self.exitGetNewTrade),
State.State('begin', self.enterBegin, self.exitBegin),
State.State('notYet', self.enterNotYet, self.exitNotYet),
State.State('checkAvailability', self.enterCheckAvailability, self.exitCheckAvailability),
State.State('notAvailable', self.enterNotAvailable, self.exitNotAvailable),
State.State('notAcceptingTrades', self.enterNotAcceptingTrades, self.exitNotAcceptingTrades),
State.State('wentAway', self.enterWentAway, self.exitWentAway),
State.State('alreadyTrading', self.enterAlreadyTrading, self.exitAlreadyTrading),
State.State('alreadyInvited', self.enterAlreadyInvited, self.exitAlreadyInvited),
State.State('askingNPC', self.enterAskingNPC, self.exitAskingNPC),
State.State('endTrade', self.enterEndTrade, self.exitEndTrade),
State.State('tradeNoMore', self.enterTradeNoMore, self.exitTradeNoMore),
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('maybe', self.enterMaybe, self.exitMaybe),
State.State('down', self.enterDown, self.exitDown),
State.State('cancel', self.enterCancel, self.exitCancel)], 'off', 'off')
guiMain = loader.loadModel('models/gui/gui_main')
self.box = OnscreenImage(parent=self, pos=(0.25, 0, 0.275), image=guiMain.find('**/general_frame_e'), scale=0.25)
self.title = DirectLabel(parent=self, relief=None, text=PLocalizer.TradeInviterTitle, text_scale=PiratesGuiGlobals.TextScaleExtraLarge, text_align=TextNode.ACenter, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_font=PiratesGlobals.getPirateOutlineFont(), pos=(0.25,
0,
0.42), image=None, image_scale=0.25)
self.message = DirectLabel(parent=self, relief=None, text='', text_scale=PiratesGuiGlobals.TextScaleLarge, text_align=TextNode.ACenter, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=11, pos=(0.25,
0,
0.325), textMayChange=1)
self.context = None
self.bOk = TradeInviterButton(text=PLocalizer.TradeInviterOK, command=self.__handleOk)
self.bOk.reparentTo(self)
self.bOk.setPos(0.2, 0, 0.05)
self.bOk.hide()
self.bCancel = TradeInviterButton(text=PLocalizer.TradeInviterCancel, command=self.__handleCancel)
self.bCancel.reparentTo(self)
self.bCancel.setPos(0.2, 0, 0.05)
self.bCancel.hide()
self.bStop = TradeInviterButton(text=PLocalizer.TradeInviterStopTrading, command=self.__handleStop)
self.bStop.reparentTo(self)
self.bStop.setPos(0.2, 0, 0.15)
self.bStop.hide()
self.bYes = TradeInviterButton(text=PLocalizer.TradeInviterYes, command=self.__handleYes)
self.bYes.reparentTo(self)
self.bYes.setPos(0.1, 0, 0.05)
self.bYes.hide()
self.bNo = TradeInviterButton(text=PLocalizer.TradeInviterNo, command=self.__handleNo)
self.bNo.reparentTo(self)
self.bNo.setPos(0.3, 0, 0.05)
self.bNo.hide()
self.fsm.enterInitialState()
if self.avId == None:
self.fsm.request('getNewTrade')
else:
self.fsm.request('begin')
return
def __init__(self, loader, parentFSM, doneEvent):
BattlePlace.BattlePlace.__init__(self, loader, doneEvent)
self.fsm = ClassicFSM.ClassicFSM('Street', [
State.State(
'start', self.enterStart, self.exitStart,
['walk', 'tunnelIn', 'doorIn', 'teleportIn', 'elevatorIn']),
State.State('walk', self.enterWalk, self.exitWalk, [
'push', 'sit', 'stickerBook', 'WaitForBattle', 'battle', 'DFA',
'trialerFA', 'doorOut', 'elevator', 'tunnelIn', 'tunnelOut',
'teleportOut', 'quest', 'stopped', 'fishing', 'purchase',
'died'
]),
State.State('sit', self.enterSit, self.exitSit, ['walk']),
State.State('push', self.enterPush, self.exitPush, ['walk']),
State.State(
'stickerBook', self.enterStickerBook, self.exitStickerBook, [
'walk', 'push', 'sit', 'battle', 'DFA', 'trialerFA',
'doorOut', 'elevator', 'tunnelIn', 'tunnelOut',
'WaitForBattle', 'teleportOut', 'quest', 'stopped',
'fishing', 'purchase'
]),
State.State('WaitForBattle', self.enterWaitForBattle,
self.exitWaitForBattle, ['battle', 'walk']),
State.State('battle', self.enterBattle, self.exitBattle,
['walk', 'teleportOut', 'died']),
State.State('doorIn', self.enterDoorIn, self.exitDoorIn, ['walk']),
State.State('doorOut', self.enterDoorOut, self.exitDoorOut,
['walk']),
State.State('elevatorIn', self.enterElevatorIn,
self.exitElevatorIn, ['walk']),
State.State('elevator', self.enterElevator, self.exitElevator,
['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', 'tunnelOut']),
State.State('DFAReject', self.enterDFAReject, self.exitDFAReject,
['walk']),
State.State(
'teleportIn', self.enterTeleportIn, self.exitTeleportIn, [
'walk', 'teleportOut', 'quietZone', 'WaitForBattle',
'battle'
]),
State.State('teleportOut', self.enterTeleportOut,
self.exitTeleportOut,
['teleportIn', 'quietZone', 'WaitForBattle']),
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('quietZone', self.enterQuietZone, self.exitQuietZone,
['teleportIn']),
State.State('quest', self.enterQuest, self.exitQuest,
['walk', 'stopped']),
State.State('stopped', self.enterStopped, self.exitStopped,
['walk']),
State.State('stopped', self.enterStopped, self.exitStopped,
['walk']),
State.State('fishing', self.enterFishing, self.exitFishing,
['walk']),
State.State('purchase', self.enterPurchase, self.exitPurchase,
['walk']),
State.State('final', self.enterFinal, self.exitFinal, ['start'])
], 'start', 'final')
self.parentFSM = parentFSM
self.tunnelOriginList = []
self.elevatorDoneEvent = 'elevatorDone'
self.halloweenLights = []
self.zone = 0
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.890000000000001, 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.14999999999999999)
self.controlKeyWarningLabel.hide()
self.waitingMoveLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForPlayersToFinishMove,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.59999999999999998, 0, -0.75),
scale=0.074999999999999997)
self.waitingMoveLabel.hide()
self.waitingSyncLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForAISync,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.59999999999999998, 0, -0.75),
scale=0.074999999999999997)
self.waitingSyncLabel.hide()
self.infoLabel = DirectLabel(text='',
text_fg=VBase4(0, 0, 0, 1),
relief=None,
pos=(0.0, 0, 0.69999999999999996),
scale=0.074999999999999997)
self.updateInfoLabel()
self.lastForceArrowUpdateTime = 0
self.sendForceArrowUpdateAsap = False
self.treasures = []
self.penalties = []
self.obstacles = []
self.controlKeyPressed = False
self.controlKeyWarningIval = None
class Pet(Avatar.Avatar):
notify = DirectNotifyGlobal.directNotify.newCategory('Pet')
SerialNum = 0
Interactions = PythonUtil.Enum('SCRATCH, BEG, EAT, NEUTRAL')
InteractAnims = {Interactions.SCRATCH: ('toPet', 'pet', 'fromPet'),
Interactions.BEG: ('toBeg', 'beg', 'fromBeg'),
Interactions.EAT: ('eat', 'swallow', 'neutral'),
Interactions.NEUTRAL: 'neutral'}
def __init__(self, forGui = 0):
Avatar.Avatar.__init__(self)
self.serialNum = Pet.SerialNum
Pet.SerialNum += 1
self.lockedDown = 0
self.setPickable(1)
self.setPlayerType(NametagGroup.CCNonPlayer)
self.animFSM = ClassicFSM('petAnimFSM', [State('off', self.enterOff, self.exitOff),
State('neutral', self.enterNeutral, self.exitNeutral),
State('neutralHappy', self.enterNeutralHappy, self.exitNeutralHappy),
State('neutralSad', self.enterNeutralSad, self.exitNeutralSad),
State('run', self.enterRun, self.exitRun),
State('swim', self.enterSwim, self.exitSwim),
State('teleportIn', self.enterTeleportIn, self.exitTeleportOut),
State('teleportOut', self.enterTeleportOut, self.exitTeleportOut),
State('walk', self.enterWalk, self.exitWalk),
State('walkHappy', self.enterWalkHappy, self.exitWalkHappy),
State('walkSad', self.enterWalkSad, self.exitWalkSad)], 'off', 'off')
self.animFSM.enterInitialState()
self.forGui = forGui
self.moodModel = None
self.__blinkName = 'petblink-' + str(self.this)
self.track = None
self.soundBackflip = None
self.soundRollover = None
self.soundPlaydead = None
self.soundTeleportIn = None
self.soundTeleportOut = None
self.teleportHole = None
return
def isPet(self):
return True
def stopAnimations(self):
if self.track:
self.track.pause()
self.stopBlink()
self.animFSM.request('off')
def delete(self):
self.stopAnimations()
self.track = None
self.soundBackflip = None
self.soundRollover = None
self.soundPlaydead = None
self.soundTeleportIn = None
self.soundTeleportOut = None
if self.teleportHole:
self.teleportHole.cleanup()
self.teleportHole = None
self.eyesOpenTexture = None
self.eyesClosedTexture = None
self.animFSM = None
self.eyes = None
self.rightPupil = None
self.rightHighlight = None
self.rightBrow = None
self.leftPupil = None
self.leftHighlight = None
self.leftBrow = None
self.color = None
Avatar.Avatar.delete(self)
return
def getDNA(self):
return self.style
def setDNA(self, dna):
if self.style:
pass
else:
self.style = dna
self.generatePet()
self.generateMoods()
self.initializeDropShadow()
self.initializeNametag3d()
self.dropShadow.setScale(0.75)
def generatePet(self):
self.loadModel('phase_4/models/char/TT_pets-mod')
self.loadAnims({'toBeg': 'phase_5/models/char/TT_pets-intoBeg',
'beg': 'phase_5/models/char/TT_pets-beg',
'fromBeg': 'phase_5/models/char/TT_pets-begOut',
'backflip': 'phase_5/models/char/TT_pets-backflip',
'dance': 'phase_5/models/char/TT_pets-heal',
'toDig': 'phase_5/models/char/TT_pets-intoDig',
'dig': 'phase_5/models/char/TT_pets-dig',
'fromDig': 'phase_5/models/char/TT_pets-digToNeutral',
'disappear': 'phase_5/models/char/TT_pets-disappear',
'eat': 'phase_5.5/models/char/TT_pets-eat',
'jump': 'phase_5/models/char/TT_pets-jump',
'neutral': 'phase_4/models/char/TT_pets-neutral',
'neutralHappy': 'phase_4/models/char/TT_pets-neutralHappy',
'neutralSad': 'phase_4/models/char/TT_pets-neutral_sad',
'toPet': 'phase_5.5/models/char/TT_pets-petin',
'pet': 'phase_5.5/models/char/TT_pets-petloop',
'fromPet': 'phase_5.5/models/char/TT_pets-petend',
'playDead': 'phase_5/models/char/TT_pets-playdead',
'fromPlayDead': 'phase_5/models/char/TT_pets-deadend',
'reappear': 'phase_5/models/char/TT_pets-reappear',
'run': 'phase_5.5/models/char/TT_pets-run',
'rollover': 'phase_5/models/char/TT_pets-rollover',
'walkSad': 'phase_5.5/models/char/TT_pets-sadwalk',
'speak': 'phase_5/models/char/TT_pets-speak',
'swallow': 'phase_5.5/models/char/TT_pets-swallow',
'swim': 'phase_5.5/models/char/TT_pets-swim',
'toBall': 'phase_5.5/models/char/TT_pets-toBall',
'walk': 'phase_5.5/models/char/TT_pets-walk',
'walkHappy': 'phase_5.5/models/char/TT_pets-walkHappy'})
self.setHeight(2)
color = None
colorIndex = self.style[5]
color = AllPetColors[colorIndex]
self.color = color
bodyType = self.style[4]
body = self.find('**/body')
tex = loader.loadTexture(BodyTextures[BodyTypes[bodyType]])
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
body.setTexture(tex, 1)
body.setColor(color)
leftFoot = self.find('**/leftFoot')
rightFoot = self.find('**/rightFoot')
texName = getFootTexture(bodyType)
tex = loader.loadTexture(texName)
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
leftFoot.setTexture(tex, 1)
rightFoot.setTexture(tex, 1)
leftFoot.setColor(color)
rightFoot.setColor(color)
for part in HeadParts + EarParts + NoseParts + TailParts:
self.find('**/' + part).stash()
colorScale = ColorScales[self.style[6]]
partColor = self.amplifyColor(color, colorScale)
headIndex = self.style[0]
if headIndex != -1:
head = self.find('**/@@' + HeadParts[headIndex])
head.setColor(partColor)
head.unstash()
earsIndex = self.style[1]
if earsIndex != -1:
ears = self.find('**/@@' + EarParts[earsIndex])
ears.setColor(partColor)
texName = getEarTexture(bodyType, EarParts[earsIndex])
if texName:
tex = loader.loadTexture(texName)
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
ears.setTexture(tex, 1)
ears.unstash()
noseIndex = self.style[2]
if noseIndex != -1:
nose = self.find('**/@@' + NoseParts[noseIndex])
nose.setColor(partColor)
nose.unstash()
tailIndex = self.style[3]
if tailIndex != -1:
tail = self.find('**/@@' + TailParts[tailIndex])
tail.setColor(partColor)
texName = TailTextures[TailParts[tailIndex]]
if texName:
if BodyTypes[bodyType] == 'giraffe':
texName = GiraffeTail
elif BodyTypes[bodyType] == 'leopard':
texName = LeopardTail
tex = loader.loadTexture(texName)
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
tail.setTexture(tex, 1)
tail.unstash()
if not self.forGui:
self.drawInFront('eyeWhites', 'body', 1)
self.drawInFront('rightPupil', 'eyeWhites', 2)
self.drawInFront('leftPupil', 'eyeWhites', 2)
self.drawInFront('rightHighlight', 'rightPupil', 3)
self.drawInFront('leftHighlight', 'leftPupil', 3)
else:
self.drawInFront('eyeWhites', 'body', -2)
self.drawInFront('rightPupil', 'eyeWhites', -2)
self.drawInFront('leftPupil', 'eyeWhites', -2)
self.find('**/rightPupil').adjustAllPriorities(1)
self.find('**/leftPupil').adjustAllPriorities(1)
eyes = self.style[7]
eyeColor = PetEyeColors[eyes]
self.eyes = self.find('**/eyeWhites')
self.rightPupil = self.find('**/rightPupil')
self.leftPupil = self.find('**/leftPupil')
self.rightHighlight = self.find('**/rightHighlight')
self.leftHighlight = self.find('**/leftHighlight')
self.rightBrow = self.find('**/rightBrow')
self.leftBrow = self.find('**/leftBrow')
self.eyes.setColor(1, 1, 1, 1)
self.rightPupil.setColor(eyeColor, 2)
self.leftPupil.setColor(eyeColor, 2)
self.rightHighlight.setColor(1, 1, 1, 1)
self.leftHighlight.setColor(1, 1, 1, 1)
self.rightBrow.setColor(0, 0, 0, 1)
self.leftBrow.setColor(0, 0, 0, 1)
self.eyes.setTwoSided(1, 1)
self.rightPupil.setTwoSided(1, 1)
self.leftPupil.setTwoSided(1, 1)
self.rightHighlight.setTwoSided(1, 1)
self.leftHighlight.setTwoSided(1, 1)
self.rightBrow.setTwoSided(1, 1)
self.leftBrow.setTwoSided(1, 1)
if self.forGui:
self.rightHighlight.hide()
self.leftHighlight.hide()
if self.style[8]:
self.eyesOpenTexture = loader.loadTexture('phase_4/maps/BeanEyeBoys2.jpg', 'phase_4/maps/BeanEyeBoys2_a.rgb')
self.eyesClosedTexture = loader.loadTexture('phase_4/maps/BeanEyeBoysBlink.jpg', 'phase_4/maps/BeanEyeBoysBlink_a.rgb')
else:
self.eyesOpenTexture = loader.loadTexture('phase_4/maps/BeanEyeGirlsNew.jpg', 'phase_4/maps/BeanEyeGirlsNew_a.rgb')
self.eyesClosedTexture = loader.loadTexture('phase_4/maps/BeanEyeGirlsBlinkNew.jpg', 'phase_4/maps/BeanEyeGirlsBlinkNew_a.rgb')
self.eyesOpenTexture.setMinfilter(Texture.FTLinear)
self.eyesOpenTexture.setMagfilter(Texture.FTLinear)
self.eyesClosedTexture.setMinfilter(Texture.FTLinear)
self.eyesClosedTexture.setMagfilter(Texture.FTLinear)
self.eyesOpen()
return None
def initializeBodyCollisions(self, collIdStr):
Avatar.Avatar.initializeBodyCollisions(self, collIdStr)
if not self.ghostMode:
self.collNode.setCollideMask(self.collNode.getIntoCollideMask() | ToontownGlobals.PieBitmask)
def amplifyColor(self, color, scale):
color = color * scale
for i in (0, 1, 2):
if color[i] > 1.0:
color.setCell(i, 1.0)
return color
def generateMoods(self):
moodIcons = loader.loadModel('phase_4/models/char/petEmotes')
self.moodIcons = self.attachNewNode('moodIcons')
self.moodIcons.setScale(2.0)
self.moodIcons.setZ(3.65)
moods = moodIcons.findAllMatches('**/+GeomNode')
for moodNum in range(0, moods.getNumPaths()):
mood = moods.getPath(moodNum)
mood.reparentTo(self.moodIcons)
mood.setBillboardPointEye()
mood.hide()
def clearMood(self):
if self.moodModel:
self.moodModel.hide()
self.moodModel = None
return
def showMood(self, mood):
if hasattr(base.cr, 'newsManager') and base.cr.newsManager:
holidayIds = base.cr.newsManager.getHolidayIdList()
if (ToontownGlobals.APRIL_FOOLS_COSTUMES in holidayIds or ToontownGlobals.SILLYMETER_EXT_HOLIDAY in holidayIds) and not mood == 'confusion':
self.speakMood(mood)
return
else:
self.clearChat()
else:
self.clearChat()
mood = Component2IconDict[mood]
if mood is None:
moodModel = None
else:
moodModel = self.moodIcons.find('**/*' + mood + '*')
if moodModel.isEmpty():
self.notify.warning('No such mood!: %s' % mood)
return
if self.moodModel == moodModel:
return
if self.moodModel:
self.moodModel.hide()
self.moodModel = moodModel
if self.moodModel:
self.moodModel.show()
return
def speakMood(self, mood):
if self.moodModel:
self.moodModel.hide()
if base.config.GetBool('want-speech-bubble', 1):
self.nametag.setChat(random.choice(TTLocalizer.SpokenMoods[mood]), CFSpeech)
else:
self.nametag.setChat(random.choice(TTLocalizer.SpokenMoods[mood]), CFThought)
def getGenderString(self):
if self.style:
if self.style[8]:
return TTLocalizer.GenderShopBoyButtonText
else:
return TTLocalizer.GenderShopGirlButtonText
def getShadowJoint(self):
if hasattr(self, 'shadowJoint'):
return self.shadowJoint
shadowJoint = self.find('**/attachShadow')
if shadowJoint.isEmpty():
self.shadowJoint = self
else:
self.shadowJoint = shadowJoint
return self.shadowJoint
def getNametagJoints(self):
joints = []
bundle = self.getPartBundle('modelRoot')
joint = bundle.findChild('attachNametag')
if joint:
joints.append(joint)
return joints
def fitAndCenterHead(self, maxDim, forGui = 0):
p1 = Point3()
p2 = Point3()
self.calcTightBounds(p1, p2)
if forGui:
h = 180
t = p1[0]
p1.setX(-p2[0])
p2.setX(-t)
self.getGeomNode().setDepthWrite(1)
self.getGeomNode().setDepthTest(1)
else:
h = 0
d = p2 - p1
biggest = max(d[0], d[2])
s = (maxDim + 0.0) / biggest
mid = (p1 + d / 2.0) * s
self.setPosHprScale(-mid[0], -mid[1] + 1, -mid[2], h, 0, 0, s, s, s)
def makeRandomPet(self):
dna = PetDNA.getRandomPetDNA()
self.setDNA(dna)
def enterOff(self):
self.stop()
def exitOff(self):
pass
def enterBall(self):
self.setPlayRate(1, 'toBall')
self.play('toBall')
def exitBall(self):
self.setPlayRate(-1, 'toBall')
self.play('toBall')
def enterBackflip(self):
self.play('backflip')
def exitBackflip(self):
self.stop('backflip')
def enterBeg(self):
delay = self.getDuration('toBeg')
self.track = Sequence(Func(self.play, 'toBeg'), Wait(delay), Func(self.loop, 'beg'))
self.track.start()
def exitBeg(self):
self.track.pause()
self.play('fromBeg')
def enterEat(self):
self.loop('eat')
def exitEat(self):
self.stop('swallow')
def enterDance(self):
self.loop('dance')
def exitDance(self):
self.stop('dance')
def enterNeutral(self):
anim = 'neutral'
self.pose(anim, random.choice(range(0, self.getNumFrames(anim))))
self.loop(anim, restart=0)
def exitNeutral(self):
self.stop('neutral')
def enterNeutralHappy(self):
anim = 'neutralHappy'
self.pose(anim, random.choice(range(0, self.getNumFrames(anim))))
self.loop(anim, restart=0)
def exitNeutralHappy(self):
self.stop('neutralHappy')
def enterNeutralSad(self):
anim = 'neutralSad'
self.pose(anim, random.choice(range(0, self.getNumFrames(anim))))
self.loop(anim, restart=0)
def exitNeutralSad(self):
self.stop('neutralSad')
def enterRun(self):
self.loop('run')
def exitRun(self):
self.stop('run')
def enterSwim(self):
self.loop('swim')
def exitSwim(self):
self.stop('swim')
def getTeleportInTrack(self):
if not self.teleportHole:
self.teleportHole = Actor.Actor('phase_3.5/models/props/portal-mod', {'hole': 'phase_3.5/models/props/portal-chan'})
track = Sequence(Wait(1.0), Parallel(self.getTeleportInSoundInterval(), Sequence(Func(self.showHole), ActorInterval(self.teleportHole, 'hole', startFrame=81, endFrame=71), ActorInterval(self, 'reappear'), ActorInterval(self.teleportHole, 'hole', startFrame=71, endFrame=81), Func(self.cleanupHole), Func(self.loop, 'neutral')), Sequence(Func(self.dropShadow.hide), Wait(1.0), Func(self.dropShadow.show))))
return track
def enterTeleportIn(self, timestamp):
self.track = self.getTeleportInTrack()
self.track.start(globalClockDelta.localElapsedTime(timestamp))
def exitTeleportIn(self):
self.track.pause()
def getTeleportOutTrack(self):
if not self.teleportHole:
self.teleportHole = Actor.Actor('phase_3.5/models/props/portal-mod', {'hole': 'phase_3.5/models/props/portal-chan'})
track = Sequence(Wait(1.0), Parallel(self.getTeleportOutSoundInterval(), Sequence(ActorInterval(self, 'toDig'), Parallel(ActorInterval(self, 'dig'), Func(self.showHole), ActorInterval(self.teleportHole, 'hole', startFrame=81, endFrame=71)), ActorInterval(self, 'disappear'), ActorInterval(self.teleportHole, 'hole', startFrame=71, endFrame=81), Func(self.cleanupHole)), Sequence(Wait(1.0), Func(self.dropShadow.hide))))
return track
def enterTeleportOut(self, timestamp):
self.track = self.getTeleportOutTrack()
self.track.start(globalClockDelta.localElapsedTime(timestamp))
def exitTeleportOut(self):
self.track.pause()
def showHole(self):
if self.teleportHole:
self.teleportHole.setBin('shadow', 0)
self.teleportHole.setDepthTest(0)
self.teleportHole.setDepthWrite(0)
self.teleportHole.reparentTo(self)
self.teleportHole.setScale(0.75)
self.teleportHole.setPos(0, -1, 0)
def cleanupHole(self):
if self.teleportHole:
self.teleportHole.reparentTo(hidden)
self.teleportHole.clearBin()
self.teleportHole.clearDepthTest()
self.teleportHole.clearDepthWrite()
def getTeleportInSoundInterval(self):
if not self.soundTeleportIn:
self.soundTeleportIn = loader.loadSfx('phase_5/audio/sfx/teleport_reappear.ogg')
return SoundInterval(self.soundTeleportIn)
def getTeleportOutSoundInterval(self):
if not self.soundTeleportOut:
self.soundTeleportOut = loader.loadSfx('phase_5/audio/sfx/teleport_disappear.ogg')
return SoundInterval(self.soundTeleportOut)
def enterWalk(self):
self.loop('walk')
def exitWalk(self):
self.stop('walk')
def enterWalkHappy(self):
self.loop('walkHappy')
def exitWalkHappy(self):
self.stop('walkHappy')
def enterWalkSad(self):
self.loop('walkSad')
def exitWalkSad(self):
self.stop('walkSad')
def trackAnimToSpeed(self, forwardVel, rotVel, inWater = 0):
action = 'neutral'
if self.isInWater():
action = 'swim'
elif forwardVel > 0.1 or abs(rotVel) > 0.1:
action = 'walk'
self.setAnimWithMood(action)
def setAnimWithMood(self, action):
how = ''
if self.isExcited():
how = 'Happy'
elif self.isSad():
how = 'Sad'
if action == 'swim':
anim = action
else:
anim = '%s%s' % (action, how)
if anim != self.animFSM.getCurrentState().getName():
self.animFSM.request(anim)
def isInWater(self):
return 0
def isExcited(self):
return 0
def isSad(self):
return 0
def startTrackAnimToSpeed(self):
self.lastPos = self.getPos(render)
self.lastH = self.getH(render)
taskMgr.add(self._trackAnimTask, self.getTrackAnimTaskName())
def stopTrackAnimToSpeed(self):
taskMgr.remove(self.getTrackAnimTaskName())
del self.lastPos
del self.lastH
def getTrackAnimTaskName(self):
return 'trackPetAnim-%s' % self.serialNum
def _trackAnimTask(self, task):
curPos = self.getPos(render)
curH = self.getH(render)
self.trackAnimToSpeed(curPos - self.lastPos, curH - self.lastH)
self.lastPos = curPos
self.lastH = curH
return Task.cont
def __blinkOpen(self, task):
self.eyesOpen()
r = random.random()
if r < 0.1:
t = 0.2
else:
t = r * 4.0 + 1
taskMgr.doMethodLater(t, self.__blinkClosed, self.__blinkName)
return Task.done
def __blinkClosed(self, task):
self.eyesClose()
taskMgr.doMethodLater(0.125, self.__blinkOpen, self.__blinkName)
return Task.done
def startBlink(self):
taskMgr.remove(self.__blinkName)
self.eyesOpen()
t = random.random() * 4.0 + 1
taskMgr.doMethodLater(t, self.__blinkClosed, self.__blinkName)
def stopBlink(self):
taskMgr.remove(self.__blinkName)
self.eyesOpen()
def eyesOpen(self):
self.eyes.setColor(1, 1, 1, 1)
self.eyes.setTexture(self.eyesOpenTexture, 1)
self.rightPupil.show()
self.leftPupil.show()
if not self.forGui:
self.rightHighlight.show()
self.leftHighlight.show()
def eyesClose(self):
self.eyes.setColor(self.color)
self.eyes.setTexture(self.eyesClosedTexture, 1)
self.rightPupil.hide()
self.leftPupil.hide()
if not self.forGui:
self.rightHighlight.hide()
self.leftHighlight.hide()
def lockPet(self):
if not self.lockedDown:
self.prevAnimState = self.animFSM.getCurrentState().getName()
self.animFSM.request('neutral')
self.lockedDown += 1
def isLockedDown(self):
return self.lockedDown != 0
def unlockPet(self):
self.lockedDown -= 1
if not self.lockedDown:
self.animFSM.request(self.prevAnimState)
self.prevAnimState = None
return
def getInteractIval(self, interactId):
anims = self.InteractAnims[interactId]
if type(anims) == types.StringType:
animIval = ActorInterval(self, anims)
else:
animIval = Sequence()
for anim in anims:
animIval.append(ActorInterval(self, anim))
return animIval
