def __init__(self, radarGui):
FSM.__init__(self, 'RadarZoom')
self.radarGui = radarGui
self.zoomOutSfx = loadSfx(SoundGlobals.SFX_GUI_ZOOM_OUT)
self.zoomInSfx = loadSfx(SoundGlobals.SFX_GUI_ZOOM_IN)
self.levels = self.DEFAULT_LEVELS
self.level = 0
def __init__(self, air, parent, activityTuple):
DistributedPartyActivityAI.__init__(self, air, parent, activityTuple)
FSM.__init__(self, 'DistributedPartyTrampolineActivityAI')
self.currentAv = 0
self.record = 0
self.jellybeans = []
self.collected = 0
def __init__(self, name):
FSM.__init__(self, name)
PandaNode.__init__(self, name)
DirectObject.__init__(self)
self.active = True
self.lastClickState = PGButton.SReady
self.clickState = PGButton.SReady
self.__hovering = False
self.clickEvent = ''
self.clickExtraArgs = []
self.contents = NodePath.anyPath(self).attachNewNode('contents')
# Create a MouseWatcherRegion:
self.regionName = self.getUniqueName() + '-region'
self.region = MouseWatcherRegion(self.regionName, 0, 0, 0, 0)
base.mouseWatcherNode.addRegion(self.region)
# Accept the mouse events:
enterPattern = base.mouseWatcherNode.getEnterPattern()
leavePattern = base.mouseWatcherNode.getLeavePattern()
buttonDownPattern = base.mouseWatcherNode.getButtonDownPattern()
buttonUpPattern = base.mouseWatcherNode.getButtonUpPattern()
self.accept(enterPattern.replace('%r', self.regionName), self.__handleMouseEnter)
self.accept(leavePattern.replace('%r', self.regionName), self.__handleMouseLeave)
self.accept(buttonDownPattern.replace('%r', self.regionName), self.__handleMouseDown)
self.accept(buttonUpPattern.replace('%r', self.regionName), self.__handleMouseUp)
def __init__(self):
FSM.__init__(self,'mouseControllerClass')
self.cameraPosPivot = render.attachNewNode( 'cameraPivot' )
self.cameraRotPivot = self.cameraPosPivot.attachNewNode( 'cameraPivot' )
self.cameraRotPivot.setHpr( STARTUP_CAMERA_HPR )
# show a point at the cameraPosPivot
self.posPivotModel = loader.loadModel( CAMERACONTROLLER_PIVOT_MODEL )
self.posPivotModel.reparentTo( self.cameraPosPivot )
self.posPivotModel.setScale( 0.1 )
self.pressedKeys = dict()
moveSpeed = 25
self.moveVec = Vec3(0)
self.moveActions = {'w': Vec3(0,moveSpeed,0),
's': Vec3(0,-moveSpeed,0),
'a': Vec3(-moveSpeed,0,0),
'd': Vec3(moveSpeed,0,0),
'e': Vec3(0,0,moveSpeed),
'q': Vec3(0,0,-moveSpeed)}
taskMgr.add(self.movePivotTask, 'movePivotTask')
self.cameraHprResets = {'shift-1': Vec3(90,0,0),
'shift-2': Vec3(180,0,0),
'shift-3': Vec3(0,-90,0),
'shift-4': Vec3(-90,0,0),
'shift-5': Vec3(0,0,0),
'shift-6': Vec3(0,90,0),}
self.backupSettings()
self.request('Disabled')
self.accept('shift-0', self.toggleLens)
def __init__(self, cr):
DistributedObject.__init__(self, cr)
FSM.__init__(self, 'ToonfestBalloonFSM')
self.avId = 0
self.flightPathIndex = 0
self.balloon = loader.loadModel('phase_6/models/events/tf_balloon')
self.balloon.reparentTo(base.render)
self.balloon.setPos(*ToonfestBalloonGlobals.BalloonBasePosition)
self.balloon.setH(250)
self.balloon.setScale(ToonfestBalloonGlobals.BalloonScale)
self.cr.parentMgr.registerParent(ToontownGlobals.SPToonfestBalloon, self.balloon)
cs = CollisionSphere(0, 0, 0, 9)
cs.setTangible(False)
self.collisionNP = self.balloon.find('**/basket_wall_collision')
self.collisionNP.node().addSolid(cs)
self.alec = NPCToons.createLocalNPC(91915)
self.alec.setPos(0.7, 0.7, 0.4)
self.alec.setH(150)
self.alec.setScale(1 / ToonfestBalloonGlobals.BalloonScale)
self.alec.initializeBodyCollisions('toon')
self.alec.setPickable(0)
self.alec.addActive()
self.alec.startBlink()
self.alec.loop('neutral')
self.flightPaths = ToonfestBalloonGlobals.generateFlightPaths(self)
self.toonFlightPaths = ToonfestBalloonGlobals.generateToonFlightPaths(self)
self.speechSequence = ToonfestBalloonGlobals.generateSpeechSequence(self)
def __init__(self, name):
FSM.__init__(self, name + "-FSM")
self.objects = set()
self.observing = 0
self.sentry = None
self.radarAxis = base.options.getLandMapRadarAxis()
self.myUpdateTask = None
def __init__(self, doneEvent = None):
FSM.__init__(self, 'PartyPlannerFSM')
DirectFrame.__init__(self)
self.doneEvent = doneEvent
self.stateArray = ['Off',
'Welcome',
'PartyEditor',
'Guests',
'Date',
'Time',
'Invitation',
'Farewell']
self.partyTime = base.cr.toontownTimeManager.getCurServerDateTime()
self.partyNowTime = base.cr.toontownTimeManager.getCurServerDateTime()
minutesToNextFifteen = 15 - self.partyTime.minute % 15
self.cleanPartyTime = self.partyTime + timedelta(minutes=minutesToNextFifteen, seconds=-self.partyTime.second)
self.partyTime = self.cleanPartyTime
self.guests = []
self.isPrivate = False
self.selectedCalendarGuiDay = None
self.gui = loader.loadModel('phase_4/models/parties/partyPlannerGUI')
self.partyDuration = timedelta(hours=PartyGlobals.DefaultPartyDuration)
self.timeTypeToMaxValue = {'hour': 23,
'minute': 59}
self.timeTypeToChangeAmount = {'hour': (1, -1),
'minute': (15, -15),
'ampm': (1, -1)}
self.partyInfo = None
self.asapMinuteRounding = base.config.GetInt('party-asap-minute-rounding', PartyGlobals.PartyPlannerAsapMinuteRounding)
self.load()
self.request('Welcome')
return
def __init__(self, brain, toonId):
FSM.__init__(self, 'AttackFSM')
self.brain = brain
self.toonId = toonId
self._walkingTo = None
self._walkTask = None
def __init__(self, air, parent, activityTuple):
DistributedPartyActivityAI.__init__(self, air, parent, activityTuple)
FSM.__init__(self, 'DistributedPartyActivityAI')
self.state = 'Idle'
self.parent = parent
self.eventId = PartyGlobals.FireworkShows.Summer
self.showStyle = random.randint(0, len(FireworkShows.shows[PartyGlobals.FireworkShows.Summer]) - 1)
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
FSM.__init__(self, 'Elevator_%s_FSM' % self.id)
self.bldgRequest = None
self.toonRequests = {}
self.deferredSlots = []
self.localToonOnBoard = 0
self.boardedAvIds = {}
self.openSfx = base.loadSfx('phase_5/audio/sfx/elevator_door_open.mp3')
self.finalOpenSfx = None
self.closeSfx = base.loadSfx('phase_5/audio/sfx/elevator_door_close.mp3')
self.elevatorFSM = None
self.finalCloseSfx = None
self.elevatorPoints = ElevatorPoints
self.type = ELEVATOR_NORMAL
self.countdownTime = ElevatorData[self.type]['countdown']
self.isSetup = 0
self.__preSetupState = None
self.bigElevator = 0
self.offTrack = [None,
None,
None,
None]
self.boardingParty = None
return
def __init__(self):
TelevisionScene.__init__(self, 'SellbotScene')
FSM.__init__(self, 'SellbotScene')
self.background = loader.loadModel('phase_9/models/cogHQ/SellbotHQLobby.bam')
self.background.reparentTo(self)
self.boss = BossCog()
dna = SuitDNA()
dna.newBossCog('s')
self.boss.setDNA(dna)
self.boss.reparentTo(self)
self.boss.setPosHpr(6.36, 34.23, 0, 169.7, 0, 0)
self.boss.loop('Bb_neutral')
self.subordinates = []
for name, (x, y, z, h, p, r) in (('mh', (-2.76, 16.68, 11.63, 195.95, 0, 0)),
('ms', (7.18, 14.98, 12.57, 153.43, 0, 0)),
('tf', (-1.55, 62.22, 15.27, 180, 0, 0))):
subordinate = Suit.Suit()
dna = SuitDNA()
dna.newSuit(name)
subordinate.setDNA(dna)
subordinate.nametag.setNametag2d(None)
subordinate.nametag.setNametag3d(None)
subordinate.reparentTo(hidden)
subordinate.setPosHpr(x, y, z, h, p, r)
self.subordinates.append(subordinate)
def __init__(self):
NodePath.__init__(self, 'ExperimentTelevision')
FSM.__init__(self, 'ExperimentTelevision')
self.model = loader.loadModel('phase_4/models/events/blimp_tv.bam')
self.model.reparentTo(self)
self.staticTex = loader.loadTexture('phase_4/maps/blimp_tv_map_01.png')
self.staticTex.setMinfilter(Texture.FTLinearMipmapLinear)
self.staticTex.setMagfilter(Texture.FTLinear)
self.chairmanTex = loader.loadTexture('phase_4/maps/blimp_tv_map_CM.png')
self.chairmanTex.setMinfilter(Texture.FTLinearMipmapLinear)
self.chairmanTex.setMagfilter(Texture.FTLinear)
self.bossbotScene = BossbotScene()
self.lawbotScene = LawbotScene()
self.cashbotScene = CashbotScene()
self.sellbotScene = SellbotScene()
self.buffer = base.win.makeTextureBuffer('television', 960, 540)
self.buffer.setSort(-1)
self.camera = base.makeCamera(self.buffer)
self.track = None
def __init__(self, mgr, estate, toon, callback):
FSM.__init__(self, 'LoadPetFSM')
self.mgr = mgr
self.estate = estate
self.toon = toon
self.callback = callback
self.done = False
def __init__(self):
TelevisionScene.__init__(self, 'CashbotScene')
FSM.__init__(self, 'CashbotScene')
self.background = loader.loadModel('phase_10/models/cogHQ/EndVault.bam')
self.background.reparentTo(self)
self.boss = BossCog()
dna = SuitDNA()
dna.newBossCog('m')
self.boss.setDNA(dna)
self.boss.reparentTo(self)
self.boss.setPosHpr(21.66, -117.47, 2.92, 228.01, 0, 0)
self.boss.loop('Bb_neutral')
self.subordinates = []
for name, (x, y, z, h, p, r) in (('rb', (33.41, -135.55, 14.68, 251.57, 0, 0)),
('mb', (38.75, -126.4, 14.68, 210.96, 0, 0))):
subordinate = Suit.Suit()
dna = SuitDNA()
dna.newSuit(name)
subordinate.setDNA(dna)
subordinate.nametag.setNametag2d(None)
subordinate.nametag.setNametag3d(None)
subordinate.reparentTo(hidden)
subordinate.setPosHpr(x, y, z, h, p, r)
self.subordinates.append(subordinate)
def __init__(self, camera, parent):
"""Arguments:
camera -- Camera to be used
parent -- Aeroplane which the camera should follow
"""
self.notifier = DirectNotify().newCategory("azure-camera")
self.camera = camera
self.parent = parent
# This gets replaced by a NodePath with all available cameras as
# children and plane node as parent in createCamNodes()
self.cameras = None
#if parent.__class__.__name__ is not "Aeroplane":
if not isinstance(self.parent, Aeroplane):
raise ParamError, "Parent must be an Aeroplane instance, " + \
"but is %s" % type(self.parent)
FSM.__init__(self, "PlaneCamera: %s" % self.parent.name)
DirectObject.__init__(self)
self.cameras = self.parent.node.find("cameras")
if self.cameras.isEmpty():
self.createCamNodes()
self.updateCamArray()
self.sideview_direction = 0
# Set up the default camera
self.setView("ThirdPerson")
def __init__(
self,
air,
lawOfficeId,
bldg,
avIds,
markerId=None,
numSeats=4,
antiShuffle=0,
minLaff=0):
DistributedElevatorFSMAI.DistributedElevatorFSMAI.__init__(
self, air, bldg, numSeats, antiShuffle=antiShuffle, minLaff=minLaff)
FSM.__init__(self, 'ElevatorFloor_%s_FSM' % self.id)
self.type = ELEVATOR_STAGE
self.countdownTime = ElevatorData[self.type]['countdown']
self.lawOfficeId = lawOfficeId
self.anyToonsBailed = 0
self.avIds = avIds
self.isEntering = 0
self.isLocked = 0
self.setLocked(0)
self.wantState = None
self.latchRoom = None
self.setLatch(markerId)
self.zoneId = bldg.zoneId
return
def __init__(self, filename):
FSM.__init__(self, 'Game')
self.savedGame = PlayerFileParser("save.xml")
self.playerData = self.savedGame.playerData
self.playerData.setShip(shipDb[self.playerData.ship.name])
self.crosshair = MouseCursor()
self.crosshair.setMode(1)
self.mainMenu = MainMenu()
self.mainMenu.hide()
self.mainMenu.buttons[0]["command"] = self.request
self.mainMenu.buttons[0]["extraArgs"] = ["Space"]
self.mainMenu.buttons[1]["command"] = self.request
self.mainMenu.buttons[1]["extraArgs"] = ["Ground"]
self.mainMenu.buttons[3]["command"] = self.quit
self.mainMenu.buttons[3]["extraArgs"] = [0]
#self.groundGui = GroundGui(self.playerData)
#self.groundWorldManager = GroundManager(self)
#self.spaceWorldManager = SpaceOdeWorldManager(self)
self.prevState = None
self.trans = Transitions(loader)
self.request("IntroMainMenu")
def __init__(self, withinTTH=False):
FSM.__init__(self, "FNAFBase")
self.withinTTH = withinTTH
if not self.withinTTH:
base.cogFont = loader.loadFont('data/vtRemingtonPortable.ttf')
base.accept("escape", self.handleEsc)
base.accept("f9", self.screenshot)
else:
from toontown.toonbase import ToontownGlobals
base.cogFont = ToontownGlobals.getSuitFont()
base.level = Level()
base.timer = Timer()
base.camControls = CameraControls()
if not self.withinTTH:
self.handleGotPhases()
self.ray = CollisionRay()
cNode = CollisionNode('mousePicker')
cNode.addSolid(self.ray)
cNode.setCollideMask(BitMask32(8))
self.cnp = base.cam.attachNewNode(cNode)
self.handler = CollisionHandlerQueue()
self.clickTrav = CollisionTraverser('cTrav')
self.clickTrav.addCollider(self.cnp, self.handler)
base.accept('mouse1', self.__handleClick)
self.night = 1
def __init__(self):
TelevisionScene.__init__(self, 'LawbotScene')
FSM.__init__(self, 'LawbotScene')
self.background = loader.loadModel('phase_11/models/lawbotHQ/LawbotCourtroom3.bam')
self.background.reparentTo(self)
self.boss = BossCog()
dna = SuitDNA()
dna.newBossCog('l')
self.boss.setDNA(dna)
self.boss.reparentTo(self)
self.boss.setPosHpr(-3.7, 0, 71.24, 180, 0, 0)
self.boss.loop('Bb_neutral')
self.chairs = []
chairModel = loader.loadModel('phase_11/models/lawbotHQ/LB_chairA.bam')
for x, y, z, h, p, r in ((-16.5, 3.73, 81.58, 23.2, 0, 0),
(8.5, 3.73, 81.58, 336.8, 0, 0)):
chair = chairModel.copyTo(self)
chair.setPosHpr(x, y, z, h, p, r)
self.chairs.append(chair)
chairModel.removeNode()
self.couches = []
couchModel = loader.loadModel('phase_11/models/lawbotHQ/LB_couchA.bam')
for x, y, z, h, p, r in ((-16.28, 19.88, 81.58, 23.2, 0, 0),
(8.55, 19.42, 81.58, 333.43, 0, 0)):
couch = couchModel.copyTo(self)
couch.setPosHpr(x, y, z, h, p, r)
self.couches.append(couch)
couchModel.removeNode()
def __init__(self, name, zoneRadii, questStep):
zoneRadii += [
1000000]
NodePath.__init__(self, name)
FSM.__init__(self, '%sFSM' % name)
ZoneLOD.__init__(self, self._QuestIndicatorNode__uniqueName, zoneRadii)
self.questStep = questStep
self.pendingOriginObj = None
self.muted = False
self.farEffect = None
self.wantBottomEffect = True
self.minimapObject = None
self.minimap = None
def originObjHere(originObj):
self.pendingOriginObj = None
self.setZoneRadii(zoneRadii)
self.placeInWorld()
self._selfRefreshTask = None
self._refreshTargetInfo = None
if self.questStep.getOriginDoId():
self.pendingOriginObj = base.cr.relatedObjectMgr.requestObjects([
self.questStep.getOriginDoId()], eachCallback = originObjHere)
else:
originObjHere(None)
def __init__(self, start="Menu"):
FSM.__init__(self, "Core Game Control")
# Optional, but prevents a warning message
base.taskMgr.setupTaskChain("world", frameBudget=-1)
self.defaultTransitions = {"Menu": ["World"],
"World": ["Menu"]}
self.demand(start)
def __init__(self, mainRef, attributes):
print("Enemy instantiated")
Unit.__init__(self)
FSM.__init__(self, 'playerFSM')
self._mainRef = mainRef
self._playerRef = mainRef.player
self._AIworldRef = mainRef.AIworld
self._enemyListRef = mainRef.enemyList
self._ddaHandlerRef = mainRef.DDAHandler
self._stateHandlerRef = mainRef.stateHandler
self._scenarioHandlerRef = mainRef.scenarioHandler
#self.topEnemyNode = mainRef.mainNode.attachNewNode('topEnemyNode')
self.initEnemyNode(mainRef.mainNode)
utils.enemyDictionary[self.enemyNode.getName()] = self
self.loadEnemyModel(attributes.modelName)
self.initAttributes(attributes)
self.initEnemyAi()
self.initEnemyDDA()
self.initEnemyCollisionHandlers()
self.initEnemyCollisionSolids()
#self.request('Idle')
self.request('Disabled')
# Start enemy updater task
self.enemyUpdaterTask = taskMgr.add(self.enemyUpdater, 'enemyUpdaterTask')
def __init__(self, zoneId, golfCourse, holeId):
FSM.__init__(self, 'Golf_%s_FSM' % self.id)
DistributedPhysicsWorldAI.DistributedPhysicsWorldAI.__init__(self, simbase.air)
GolfHoleBase.GolfHoleBase.__init__(self)
self.zoneId = zoneId
self.golfCourse = golfCourse
self.holeId = holeId
self.avIdList = golfCourse.avIdList[:]
self.watched = [0,
0,
0,
0]
self.barrierPlayback = None
self.trustedPlayerId = None
self.activeGolferIndex = None
self.activeGolferId = None
self.holeInfo = GolfGlobals.HoleInfo[self.holeId]
self.teeChosen = {}
for avId in self.avIdList:
self.teeChosen[avId] = -1
self.ballPos = {}
for avId in self.avIdList:
self.ballPos[avId] = Vec3(0, 0, 0)
self.playStarted = False
return
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, base.cr)
FSM.__init__(self, "Golf_%s_FSM" % self.id)
self.waitingStartLabel = DirectLabel(
text=TTLocalizer.MinigameWaitingForOtherToons,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.6, 0, -0.75),
scale=0.075,
)
self.waitingStartLabel.hide()
self.avIdList = []
self.remoteAvIdList = []
self.exitedAvIdList = []
self.toonPanels = []
self.exitedPanels = []
self.exitedToonsWithPanels = []
self.localAvId = base.localAvatar.doId
self.hasLocalToon = 0
self.modelCount = 500
self.cleanupActions = []
self.courseId = None
self.scores = {}
self.curHoleIndex = 0
self.golfRewardDialog = None
self.rewardIval = None
self.scoreBoard = None
self.exit = False
self.drivingToons = []
return
def __init__(self, cr):
DistributedObject.__init__(self, cr)
FSM.__init__(self, 'FlippyStandFSM')
self.flippyStand = Actor.Actor('phase_4/models/events/election_flippyStand-mod', {'idle': 'phase_4/models/events/election_flippyStand-idle'})
self.flippyStand.reparentTo(render)
self.flippyStand.setScale(0.55)
self.flippyStand.setHpr(315, 0, 349.7)
self.flippyStand.setPos(180, -250, 9.58)
self.flippyStand.exposeJoint(None, 'modelRoot', 'LInnerShoulder')
flippyTable = self.flippyStand.find('**/LInnerShoulder')
self.flippyStand.exposeJoint(None, 'modelRoot', 'Box_Joint')
wheelbarrowJoint = self.flippyStand.find('**/Box_Joint').attachNewNode('Pie_Joint')
wheelbarrow = self.flippyStand.find('**/Box')
wheelbarrow.setPosHprScale(-2.39, 0.0, 1.77, 0.0, 0.0, 6.0, 1.14, 1.54, 0.93)
pie = loader.loadModel('phase_3.5/models/props/tart')
pieS = pie.copyTo(flippyTable)
pieS.setPosHprScale(-2.61, -0.37, -1.99, 355.6, 90.0, 4.09, 1.6, 1.6, 1.6)
for pieSettings in ElectionGlobals.FlippyWheelbarrowPies:
pieModel = pie.copyTo(wheelbarrowJoint)
pieModel.setPosHprScale(*pieSettings)
wheelbarrowJoint.setPosHprScale(3.94, 0.0, 1.06, 270.0, 344.74, 0.0, 1.43, 1.12, 1.0)
self.restockSfx = loader.loadSfx('phase_9/audio/sfx/CHQ_SOS_pies_restock.ogg')
cs = CollisionBox(Point3(7, 0, 0), 12, 5, 18)
self.pieCollision = self.flippyStand.attachNewNode(CollisionNode('wheelbarrow_collision'))
self.pieCollision.node().addSolid(cs)
self.accept('enter' + self.pieCollision.node().getName(), self.handleWheelbarrowCollisionSphereEnter)
self.flippyStand.loop('idle')
def __init__(self, air, av):
FSM.__init__(self, self.__class__.__name__)
self.air = air
self.av = av
self.callback = None
def __init__(self, gameDO):
FSM.__init__(self, 'CannonDefenseFSM')
self._resultScreen = None
self._gameOverScreen = None
self._victoryScreen = None
self._countDownUI = None
self._gameDO = gameDO
self._CannonDefenseFSM__lblwaitingFor = None
self.defaultTransitions = {
'WaitingForPlayers': [
'Tutorial'],
'Tutorial': [
'WaitingForPlayers',
'Wave'],
'Wave': [
'ResultScreen',
'WaitingForPlayers',
'Defeat',
'Victory'],
'ResultScreen': [
'WaitingForPlayers',
'Wave'],
'Defeat': [
'WaitingForPlayers',
'Wave'],
'Victory': [
'WaitingForPlayers',
'Wave'] }
def __init__(self, waveNumber, bonusRound, maxWaves, roundComplete):
FSM.__init__(self, 'CannonDefenseScoreBoardFSM')
DirectFrame.__init__(self, frameSize = (0, 2.4060000000000001, 0, 1.5), pos = (-1.2, 0, -0.69999999999999996), sortOrder = 0)
try:
binOrder = 0
if roundComplete:
binOrder = 10
self.setBin('gui-cannonDefense', binOrder)
self.loadBackGround()
actualWaveNumber = waveNumber + bonusRound * maxWaves
self.panel1 = CannonDefenseEndOfWavePanel(actualWaveNumber, roundComplete, 1, 2, parent = self, frameColor = (0, 0, 0, 0), frameSize = (0, 2.4060000000000001, 0, 1.5))
if roundComplete:
self.panel1.nextButton['command'] = self.request
self.panel1.nextButton['extraArgs'] = [
'Panel3']
self.panel3 = CannonDefenseGameStatsPanel(roundComplete, 2, 2, parent = self, frameColor = (0, 0, 0, 0), frameSize = (0, 2.4060000000000001, 0, 1.5))
self.panel3.prevButton['command'] = self.request
self.panel3.prevButton['extraArgs'] = [
'Panel1']
self.request('Panel1')
except:
self.destroy()
raise
def __init__(self, parent):
"""Arguments:
parent -- Aeroplane which the camera should follow
"""
# Used for debugging. Verbosity is set in config file.
# Usually this is called self.notify, but in this case it would
# override FSM's own.
self.notifier = DirectNotify().newCategory("azure-camera")
self.parent = parent
# Replaced by a NodePath with all available cameras as children and
# plane node as parent.
self.__cameras = None
#if parent.__class__.__name__ is not "Aeroplane":
if not isinstance(self.parent, Aeroplane):
raise ParamError, "Parent must be an Aeroplane instance, but is %s" % type(self.parent)
FSM.__init__(self, "PlaneCamera: %s" % self.parent.name)
try:
self.camera = base.camera
except:
raise BaseMissing
self.__cameras = self.parent.node.find("cameras")
if self.__cameras.isEmpty():
self.createCamNodes()
self.updateCamArray()
self.sideview_direction = 0
# Set up the default camera
self.setCameraMode("ThirdPerson")
def __init__(self, cr):
FSM.__init__(self, 'robot')
self.cr = cr
# Allow a lot of time for other processes.
base.setSleep(0.1)
self.mouse = VirtualMouse('vmouse')
self.mouse.setWindowSize(*self.WindowSize)
np = base.dataRoot.attachNewNode(self.mouse)
if base.mouseWatcher:
base.mouseWatcher.reparentTo(np)
else:
base.mouseWatcher = np.attachNewNode(MouseWatcher('watcher'))
base.mouseWatcherNode = base.mouseWatcher.node()
bt = base.mouseWatcher.attachNewNode(ButtonThrower('buttons'))
base.camera = NodePath('camera')
base.cam = base.camera.attachNewNode(Camera('cam'))
base.camNode = base.cam.node()
self.task = None
self.accept(self.cr.uniqueName('gameOver'), self.gameOver)
self.request('Idle')
def __init__(self, air, bldg, numSeats = 4, antiShuffle = 0, minLaff = 0):
DistributedObjectAI.DistributedObjectAI.__init__(self, air)
FSM.__init__(self, 'Elevator_%s_FSM' % self.id)
self.type = ELEVATOR_NORMAL
self.countdownTime = ElevatorData[self.type]['countdown']
self.bldg = bldg
self.bldgDoId = bldg.getDoId()
self.seats = []
for seat in xrange(numSeats):
self.seats.append(None)
self.accepting = 0
self.setAntiShuffle(antiShuffle)
self.setMinLaff(minLaff)
if self.antiShuffle:
if not hasattr(simbase.air, 'elevatorTripId'):
simbase.air.elevatorTripId = 1
self.elevatorTripId = simbase.air.elevatorTripId
simbase.air.elevatorTripId += 1
else:
self.elevatorTripId = 0
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
FSM.__init__(self, 'staringBlock_%s_FSM' % DistributedStartingBlock.id)
self.avId = 0
self.av = None
self.lastAvId = 0
self.avatar = None
self.kartPad = None
self.collNode = None
self.movieNode = None
self.movieTrack = None
self.collSphere = None
self.collNodePath = None
self.localToonKarting = 0
self.kartNode = None
self.kart = None
self.holeActor = None
self.exitRequested = False
self.id = DistributedStartingBlock.id
DistributedStartingBlock.id += 1
return
def __init__(self, av):
FSM.__init__(self, 'MotionFSM')
self.av = av
self.avHeight = 5
self.cannotFloat = 0
self._MotionFSM__submerged = None
self._MotionFSM__overwater = None
self._MotionFSM__inwater = None
self.motionAnimFSM = MotionAnimFSM(self.av)
if hasattr(self.av, 'getAnimInfo'):
self.setAnimInfo(self.av.getAnimInfo('LandRoam'))
self.lifterDelayFrames = 0
self._MotionFSM__locked = 0
self.movementKeys = {}
keys = ('arrow_up', 'arrow_down', 'arrow_left', 'arrow_right', 'w',
's', 'a', 'd', 'q', 'e')
for key in keys:
self.movementKeys[key] = 0
self.accept(key, self.setMovementTrack, extraArgs=[key, 1])
self.accept(key + '-up', self.setMovementTrack, extraArgs=[key, 0])
def __init__(self, waveNumber, bonusRound, maxWaves, roundComplete):
FSM.__init__(self, 'CannonDefenseScoreBoardFSM')
DirectFrame.__init__(self,
frameSize=(0, 2.4060000000000001, 0, 1.5),
pos=(-1.2, 0, -0.69999999999999996),
sortOrder=0)
try:
binOrder = 0
if roundComplete:
binOrder = 10
self.setBin('gui-cannonDefense', binOrder)
self.loadBackGround()
actualWaveNumber = waveNumber + bonusRound * maxWaves
self.panel1 = CannonDefenseEndOfWavePanel(
actualWaveNumber,
roundComplete,
1,
2,
parent=self,
frameColor=(0, 0, 0, 0),
frameSize=(0, 2.4060000000000001, 0, 1.5))
if roundComplete:
self.panel1.nextButton['command'] = self.request
self.panel1.nextButton['extraArgs'] = ['Panel3']
self.panel3 = CannonDefenseGameStatsPanel(
roundComplete,
2,
2,
parent=self,
frameColor=(0, 0, 0, 0),
frameSize=(0, 2.4060000000000001, 0, 1.5))
self.panel3.prevButton['command'] = self.request
self.panel3.prevButton['extraArgs'] = ['Panel1']
self.request('Panel1')
except:
self.destroy()
raise
def __init__(self, zoneId, avIds, courseId, preferredHoleId=None):
FSM.__init__(self, 'GolfCourse_%s_FSM' % zoneId)
DistributedObjectAI.DistributedObjectAI.__init__(self, simbase.air)
self.notify.debug('GOLF COURSE: init')
self.zoneId = zoneId
self.currentHole = None
self.avIdList = []
self.avStateDict = {}
self.addExpectedGolfers(avIds)
self.courseId = courseId
self.preferredHoleId = preferredHoleId
self.courseInfo = GolfGlobals.CourseInfo[self.courseId]
self.numHoles = self.courseInfo['numHoles']
self.holeIds = self.calcHolesToUse()
self.notify.debug('self.holeIds = %s' % self.holeIds)
self.numHolesPlayed = 0
self.curHoleIndex = 0
self.trophyListLen = 0
self.courseBestListLen = 0
self.holeBestListLen = 0
self.cupListLen = 0
self.scores = {}
self.aimTimes = {}
self.startingHistory = {}
self.endingHistory = {}
self.startingHoleBest = {}
self.endingHoleBest = {}
self.startingCourseBest = {}
self.endingCourseBest = {}
self.startingCups = {}
self.endingCups = {}
self.initHistory()
self.newTrophies = {}
self.newHoleBest = {}
self.newCourseBest = {}
self.newCups = {}
self.drivingToons = []
self.__barrier = None
self.winnerByTieBreak = 0
return
def __init__(self, air, lawOfficeId,bldg, avIds, markerId = None, numSeats = 4, antiShuffle = 0, minLaff = 0):
DistributedElevatorFSMAI.DistributedElevatorFSMAI.__init__(
self, air, bldg, numSeats, antiShuffle = antiShuffle, minLaff = minLaff)
FSM.__init__( self, "ElevatorFloor_%s_FSM" % ( self.id ) )
# Do we need this?
# self.zoneId, dummy = bldg.getExteriorAndInteriorZoneId()
# Flag that tells if any Toon has jumped out of the elevator yet
# (this is used to prevent the griefers who jump off at the last
# second)
# self.type = ElevatorConstants.ELEVATOR_STAGE
self.type = ElevatorConstants.ELEVATOR_COUNTRY_CLUB
self.countdownTime = ElevatorConstants.ElevatorData[self.type]['countdown']
self.lawOfficeId = lawOfficeId
self.anyToonsBailed = 0
self.avIds = avIds
self.isEntering = 0
self.isLocked = 0
self.setLocked(0)
self.wantState = None
self.latchRoom = None
self.setLatch(markerId)
self.zoneId = bldg.zoneId
def __init__(self,
serialNum,
maze,
randomNumGen,
difficulty,
startTile,
dnaName,
cogdoSuitType,
walkAnimName=None):
data = Globals.SuitData[cogdoSuitType]
MazeSuit.__init__(
self,
serialNum,
maze,
randomNumGen,
data['cellWalkPeriod'],
difficulty,
dnaName,
startTile=startTile,
walkSameDirectionProb=Globals.SuitWalkSameDirectionProb,
walkTurnAroundProb=Globals.SuitWalkTurnAroundProb,
uniqueRandomNumGen=False,
walkAnimName=walkAnimName)
FSM.__init__(self, 'CogdoMazeSuit')
CogdoMazeSplattable.__init__(
self, self.suit,
'%s-%i' % (Globals.SuitCollisionName, self.serialNum), 1.5)
if 'scale' in data:
self.suit.setScale(data['scale'])
self.suit.nametag3d.stash()
self.suit.nametag.destroy()
self.hp = data['hp']
self.type = cogdoSuitType
self.memos = data['memos']
self.deathSuit = self.suit.getLoseActor()
self.deathSuit.pose('lose', 0)
BattleParticles.loadParticles()
self._initSfx()
def __init__(self, model, **kw):
NodePath.__init__(self, self.__class__.__name__)
FSM.__init__(self, self.__class__.__name__)
self.pos = kw.get('pos', (0, 0, 0))
self.hpr = kw.get('hpr', (0, 0, 0))
self.scale = kw.get('scale', 1)
self.color = kw.get('color')
self.setPos(self.pos)
self.setHpr(self.hpr)
self.setScale(self.scale)
if self.color:
self.setColor(self.color)
if model:
doorway = model.find('**/Doorway1')
doorway.find('**/doortop').removeNode()
doorway.find('**/doorbottom').removeNode()
doorway.reparentTo(self)
self.doorLeft = doorway.find('**/doorLeft')
self.doorRight = doorway.find('**/doorRight')
def __init__(self, mainRef):
print("Player instantiated")
Unit.__init__(self)
FSM.__init__(self, 'playerFSM')
self._hudRef = None
self._mainRef = mainRef
self._enemyListRef = mainRef.enemyList
self._ddaHandlerRef = mainRef.DDAHandler
self._mapHandlerRef = mainRef.mapHandler
self._stateHandlerRef = mainRef.stateHandler
self._scenarioHandlerRef = mainRef.scenarioHandler
self.playerNode = mainRef.mainNode.attachNewNode('playerNode')
self.initPlayerAttributes()
self.initPlayerModel()
self.initPlayerCamera()
self.initPlayerAbilities()
self.initPlayerCollisionHandlers()
self.initPlayerCollisionSolids()
self.initPlayerDDA()
# Start mouse picking and movement
self.mouseHandler = utils.MouseHandler(self)
# Start player update task
playerUpdateTask = taskMgr.add(self.playerUpdate, 'playerUpdateTask')
# Initialize player FSM state
self.request('Idle')
DO = DirectObject()
DO.accept('shift-mouse1', self.onShiftDown)
DO.accept('shift-up', self.onShiftUp)
self._shiftButtonDown = False
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
FSM.__init__(self, 'Elevator_%s_FSM' % self.id)
self.bldgRequest = None
self.toonRequests = {}
self.deferredSlots = []
self.localToonOnBoard = 0
self.boardedAvIds = {}
self.openSfx = base.loadSfx('phase_5/audio/sfx/elevator_door_open.mp3')
self.finalOpenSfx = None
self.closeSfx = base.loadSfx(
'phase_5/audio/sfx/elevator_door_close.mp3')
self.elevatorFSM = None
self.finalCloseSfx = None
self.elevatorPoints = ElevatorPoints
self.type = ELEVATOR_NORMAL
self.countdownTime = ElevatorData[self.type]['countdown']
self.isSetup = 0
self._DistributedElevatorFSM__preSetupState = None
self.bigElevator = 0
self.offTrack = [None, None, None, None]
self.boardingParty = None
def __init__(self, **kwargs):
animes = {}
for a, b, c in os.walk('models/char/animes'):
for d in c:
animes[d] = 'models/char/animes/%s' % (d)
super(character, self).__init__(kwargs['char'], anims=animes)
self.name = kwargs['name']
FSM.__init__(self, self.name)
self.setH(180)
self.setupAnimes()
self.interval_setup()
self.setPos(0, 0, -.2)
self.setScale(.2)
self.lockedOnTarget = True
self.targets = []
self.anim_playList = []
self.isAction = {
'run': False,
'jump': False,
'hit_distance': False,
'idle': False,
'jumpPunch': False,
'punch': False,
'kick': False,
'strifeLeft': False,
'strifeRight': False,
'runLeft': False,
'runRight': False
}
self.animes = {
'jump': self.jumpping,
'run': self.running,
'jumpPunch': self.jumpPunch
}
inputState.watch('run', 'player1axis1', None)
def __init__(self, name='map-manager'):
FSM.__init__(self, name)
'''
index 关卡
room 当前房间对象
rooms 当前关卡的房间信息
hero 当前的英雄信息
masterRoomVisitedNum 当前通过的主线房间个数
curRoomCode 当前的房间号
'''
self.index = 0
self.gameNP = render.attachNewNode('game')
self.room = None
self.rooms = []
self.hero = None
self.masterRoomVisitedNum = 0
self.preRoomCode = 0
self._init_accept()
self.videoDict = {}
# 保存英雄初始信息
self.initHeroInfo = None
def __init__(self):
ShowBase.__init__(self)
FSM.__init__(self, "FSM-Game")
# self.win
base.enableParticles()
self.playerName = ""
self.IsFullScreen = False
self.blade_runner = player.Player(self.playerName)
self.disableMouse()
self.plight = PointLight("plight")
self.plight.setColor((1, 1, 1, 1))
self.plnp = self.render.attachNewNode(self.plight)
self.render.setLight(self.plnp)
self.windowProps = WindowProperties()
self.intro = logoscreen.Logoscreen()
self.intro.start()
self.crawl = crawl.testCrawl()
self.accept('1', self.crawl.start)
self.menu = menu.Menu(self.windowProps, self)
self.accept('2', self.menu.start)
self.l1 = level1.Level1()
self.accept('3', self.l1.start)
self.l2 = level2.Level2()
self.accept('4', self.l2.start)
self.l3 = level3.Level3()
self.accept('5', self.l3.start)
self.l4 = level4.Level4()
self.accept('6', self.l4.start)
#ENDGAME SCREEN WITH REPORT
self.end = endgame.Endgame()
self.accept('7', self.end.start)
def __init__(self, air, zones, avId):
FSM.__init__(self, 'TutorialFSM')
self.air = air
self.zones = zones
self.avId = avId
self.suit = None
self.flippy = None
tutorialTomDesc = NPCToons.NPCToonDict.get(20000)
self.tutorialTom = NPCToons.createNPC(self.air, 20000, tutorialTomDesc, self.zones.SHOP, 0)
self.tutorialTom.setTutorial(1)
hqHarryDesc = (
-1, TTLocalizer.TutorialHQOfficerName, ('dls', 'ms', 'm', 'm', 6, 0, 6, 6, 0, 10, 0, 10, 0, 9), 'm', 1,
NPCToons.NPC_HQ)
self.hqHarry = NPCToons.createNPC(self.air, 20002, hqHarryDesc, self.zones.HQ, 0)
self.hqHarry.setTutorial(1)
self.building = TutorialBuildingAI(self.air, zones.STREET, zones.SHOP, self.tutorialTom.getDoId())
self.hq = HQBuildingAI(self.air, zones.STREET, zones.HQ, 1)
self.forceTransition('Introduction')
def __init__(self, id, toon):
FSM.__init__(self, 'CogdoMazePlayer')
CogdoMazeSplattable.__init__(
self, toon, '%s-%i' % (Globals.PlayerCollisionName, id), 0.5)
self.id = id
self.toon = toon
self.defaultTransitions = {
'Off': ['Ready'],
'Ready': ['Normal', 'Off'],
'Normal': ['Hit', 'Done', 'Off'],
'Hit': ['Normal', 'Done', 'Off'],
'Done': ['Off']
}
self.toon.reparentTo(render)
self.gagModel = CogdoUtil.loadMazeModel('waterBalloon')
self.equippedGag = None
self._toonHitSfx = base.cogdoGameAudioMgr.createSfx(
'toonHit', self.toon)
self._throwSfx = base.cogdoGameAudioMgr.createSfxIval('throw')
self.accept(toon.getDisableEvent(), self.removed)
self.request('Off')
return
def __init__(self, zoneId, golfCourse, holeId):
FSM.__init__(self, 'Golf_%s_FSM' % self.id)
DistributedPhysicsWorldAI.DistributedPhysicsWorldAI.__init__(
self, simbase.air)
GolfHoleBase.GolfHoleBase.__init__(self)
self.zoneId = zoneId
self.golfCourse = golfCourse
self.holeId = holeId
self.avIdList = golfCourse.avIdList[:]
self.watched = [0, 0, 0, 0]
self.barrierPlayback = None
self.trustedPlayerId = None
self.activeGolferIndex = None
self.activeGolferId = None
self.holeInfo = GolfGlobals.HoleInfo[self.holeId]
self.teeChosen = {}
for avId in self.avIdList:
self.teeChosen[avId] = -1
self.ballPos = {}
for avId in self.avIdList:
self.ballPos[avId] = Vec3(0, 0, 0)
self.playStarted = False
def __init__(self, world, guardKey):
Suit.__init__(self)
FSM.__init__(self, 'FactorySneakGuardSuit')
self.gameWorld = world
self.guardKey = guardKey
self.viewDistanceTaskName = self.VIEW_DISTANCE_TASK_NAME + "-" + str(
id(self))
self.diedTaskName = "GuardDied-" + str(id(self))
self.health = 0
self.maxHealth = 0
self.eyeLight = None
self.eyeLens = None
self.eyeNode = None
self.moveTrack = None
self.trav = None
self.rayNP = None
self.queue = None
self.currentKey = self.guardKey
self.firstPoint = CGG.GuardPointData[self.guardKey]
self.walkTrack = None
self.pathQueue = []
self.currentPathIndex = 0
def __init__(self, air, circuitPoints=[], circuitWinnings=[]):
DistributedObjectAI.__init__(self, air)
FSM.__init__(self, 'DistributedRaceAI')
self.air = air
self.zoneId = 0
self.trackId = 0
self.raceType = 0
self.circuitLoop = []
self.avatars = []
self.finishedAvatars = []
self.startingPlaces = []
self.avatarKarts = []
self.lapCount = 1
self.gags = {}
self.avatarGags = {}
self.livingGags = []
self.currentlyAffectedByAnvil = {}
self.avatarProgress = {}
self.circuitPoints = circuitPoints
self.circuitWinnings = circuitWinnings
self.quitAvatars = []
self.startTime = globalClockDelta.networkToLocalTime(globalClockDelta.getRealNetworkTime()) + 3
def __init__(self, avId, activity, h):
FSM.__init__( self, self.__class__.__name__ )
self.notify.debug("init : avId = %s, activity = %s " % (avId, activity))
self.avId = avId
self.activity = activity
self.isLocal = (avId == base.localAvatar.doId)
self.toon = self.activity.getAvatar(self.avId)
self.toonH = h
self.danceNode = None
self.danceMoveSequence = None
self.lastAnim = None
self.defaultTransitions = {"Init" : ["Run", "DanceMove", "Cleanup"],
"DanceMove" : ["Run", "DanceMove", "Cleanup"],
"Run" : ["Run", "DanceMove", "Cleanup"],
"Cleanup": [],
}
#self.unexpectedExit = False
self.enteredAlready = False
def __init__(self, doneEvent=None):
FSM.__init__(self, 'PartyPlannerFSM')
DirectFrame.__init__(self)
self.doneEvent = doneEvent
self.stateArray = [
'Off',
'Welcome',
'PartyEditor',
#'Guests', jjkoletar: this should mean that it skips over the guests state
'Date',
'Time',
'Invitation',
'Farewell'
]
self.partyTime = base.cr.toontownTimeManager.getCurServerDateTime()
self.partyNowTime = base.cr.toontownTimeManager.getCurServerDateTime()
minutesToNextFifteen = 15 - self.partyTime.minute % 15
self.cleanPartyTime = self.partyTime + timedelta(
minutes=minutesToNextFifteen, seconds=-self.partyTime.second)
self.partyTime = self.cleanPartyTime
self.guests = []
self.isPrivate = False
self.selectedCalendarGuiDay = None
self.gui = loader.loadModel('phase_4/models/parties/partyPlannerGUI')
self.partyDuration = timedelta(hours=PartyGlobals.DefaultPartyDuration)
self.timeTypeToMaxValue = {'hour': 23, 'minute': 59}
self.timeTypeToChangeAmount = {
'hour': (1, -1),
'minute': (15, -15),
'ampm': (1, -1)
}
self.partyInfo = None
self.asapMinuteRounding = base.config.GetInt(
'party-asap-minute-rounding',
PartyGlobals.PartyPlannerAsapMinuteRounding)
self.load()
self.request('Welcome')
return
def __init__(self):
FSM.__init__(self, 'mouseControllerClass')
self.cameraPosPivot = render.attachNewNode('cameraPivot')
self.cameraRotPivot = self.cameraPosPivot.attachNewNode('cameraPivot')
self.cameraRotPivot.setHpr(STARTUP_CAMERA_HPR)
# show a point at the cameraPosPivot
self.posPivotModel = loader.loadModel(CAMERACONTROLLER_PIVOT_MODEL)
self.posPivotModel.reparentTo(self.cameraPosPivot)
self.posPivotModel.setScale(0.1)
self.pressedKeys = dict()
moveSpeed = 25
self.moveVec = Vec3(0)
self.moveActions = {
'w': Vec3(0, moveSpeed, 0),
's': Vec3(0, -moveSpeed, 0),
'a': Vec3(-moveSpeed, 0, 0),
'd': Vec3(moveSpeed, 0, 0),
'e': Vec3(0, 0, moveSpeed),
'q': Vec3(0, 0, -moveSpeed)
}
taskMgr.add(self.movePivotTask, 'movePivotTask')
self.cameraHprResets = {
'shift-1': Vec3(90, 0, 0),
'shift-2': Vec3(180, 0, 0),
'shift-3': Vec3(0, -90, 0),
'shift-4': Vec3(-90, 0, 0),
'shift-5': Vec3(0, 0, 0),
'shift-6': Vec3(0, 90, 0),
}
self.backupSettings()
self.request('Disabled')
self.accept('shift-0', self.toggleLens)
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, base.cr)
FSM.__init__(self, 'Golf_%s_FSM' % self.id)
self.waitingStartLabel = DirectLabel(text = TTLocalizer.MinigameWaitingForOtherPlayers, text_fg = VBase4(1, 1, 1, 1), relief = None, pos = (-0.59999999999999998, 0, -0.75), scale = 0.074999999999999997)
self.waitingStartLabel.hide()
self.avIdList = []
self.remoteAvIdList = []
self.exitedAvIdList = []
self.toonPanels = []
self.exitedPanels = []
self.exitedToonsWithPanels = []
self.localAvId = base.localAvatar.doId
self.hasLocalToon = 0
self.modelCount = 500
self.cleanupActions = []
self.courseId = None
self.scores = { }
self.curHoleIndex = 0
self.golfRewardDialog = None
self.rewardIval = None
self.scoreBoard = None
self.exit = False
self.drivingToons = []
def __init__(self, parent, chatMgr, whiteListEntry, *args, **kw):
optiondefs = (('relief', None, None), ('state', DGG.DISABLED, None),
('frameSize', (0, 1, 0, 0.75),
None), ('frameColor', (1, 0, 1, 0.2), None))
self.defineoptions(kw, optiondefs)
DirectFrame.__init__(self, parent, *args, **kw)
self.initialiseoptions(ChatBar)
FSM.__init__(self, 'ChatBar')
self.whiteListEnabled = base.config.GetBool('whitelist-chat-enabled',
True)
self.openChatEnabled = base.config.GetBool('open-chat-enabled', True)
self.noChat = not (self.whiteListEnabled or self.openChatEnabled)
self.chatTabs = None
self.whisperTabs = None
self.chatMgr = chatMgr
self.slideIval = None
self.whisperNameLabel = None
self.whisperPrefixLabel = None
self.percentage = 1.0
self.iPercentage = 1.0
self.myTextScale = PiratesGuiGlobals.TextScaleLarge * 1.1
self.setupGui(whiteListEntry)
self.request('Hidden')
def __init__(self, cr):
DistributedObject.__init__(self, cr)
FSM.__init__(self, 'FlippyStandFSM')
self.flippyStand = Actor.Actor(
'phase_4/models/events/election_flippyStand-mod',
{'idle': 'phase_4/models/events/election_flippyStand-idle'})
self.flippyStand.reparentTo(render)
self.flippyStand.setScale(0.55)
self.flippyStand.setHpr(315, 0, 349.7)
self.flippyStand.setPos(180, -250, 9.58)
self.flippyStand.exposeJoint(None, 'modelRoot', 'LInnerShoulder')
flippyTable = self.flippyStand.find('**/LInnerShoulder')
self.flippyStand.exposeJoint(None, 'modelRoot', 'Box_Joint')
wheelbarrowJoint = self.flippyStand.find('**/Box_Joint').attachNewNode(
'Pie_Joint')
wheelbarrow = self.flippyStand.find('**/Box')
wheelbarrow.setPosHprScale(-2.39, 0.0, 1.77, 0.0, 0.0, 6.0, 1.14, 1.54,
0.93)
pie = loader.loadModel('phase_3.5/models/props/tart')
pieS = pie.copyTo(flippyTable)
pieS.setPosHprScale(-2.61, -0.37, -1.99, 355.6, 90.0, 4.09, 1.6, 1.6,
1.6)
for pieSettings in ElectionGlobals.FlippyWheelbarrowPies:
pieModel = pie.copyTo(wheelbarrowJoint)
pieModel.setPosHprScale(*pieSettings)
wheelbarrowJoint.setPosHprScale(3.94, 0.0, 1.06, 270.0, 344.74, 0.0,
1.43, 1.12, 1.0)
self.restockSfx = loader.loadSfx(
'phase_9/audio/sfx/CHQ_SOS_pies_restock.ogg')
cs = CollisionBox(Point3(7, 0, 0), 12, 5, 18)
self.pieCollision = self.flippyStand.attachNewNode(
CollisionNode('wheelbarrow_collision'))
self.pieCollision.node().addSolid(cs)
self.accept('enter' + self.pieCollision.node().getName(),
self.handleWheelbarrowCollisionSphereEnter)
self.flippyStand.loop('idle')
def __init__(self):
DirectFrame.__init__(self,
parent=aspect2d,
pos=(0, 0, 0.93),
scale=0.7)
FSM.__init__(self, 'GagSelectionGui')
self.setTransparency(TransparencyAttrib.MDual)
self.tracks = []
self.currentTrack = 0
self.currentGag = None
self.fwdShakeIval = None
self.revShakeIval = None
self.newTrackSound = None
self.keyScrollSound = None
self.selectSound = None
self.selectDenySound = None
self.lastActivityTime = 0.0
self.activityTask = None
self.midpoint = 0.0
self.ammoFrame = DirectFrame(parent=self,
pos=(0, 0, -0.2),
image='phase_14/maps/status_bar.png',
image_scale=(0.461 * 0.7, 0, 0.098),
relief=None)
self.ammoFrame.hide()
self.ammoTitle = OnscreenText(parent=self.ammoFrame,
text='SUPPLY',
fg=(0, 0, 0, 0.65),
align=TextNode.ALeft,
pos=(-0.37 * 0.7, -0.015, 0))
self.ammoText = OnscreenText(parent=self.ammoFrame,
text='',
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, 1),
align=TextNode.ARight,
pos=(0.37 * 0.7, -0.015, 0))
def __init__(self, game):
FSM.__init__(self, "camera")
self.game = game
self.game.disableMouse()
self.speed = 15.0
self.intervalSpeed = 2.0
self.playerNp = self.game.player.np
self.playerNp.setTransparency(TransparencyAttrib.MAlpha)
self.gameNp = NodePath("gameCam")
self.gameNp.setPos(0, 0, 0)
self.gameNp.reparentTo(self.game.render)
self.gameNp2 = NodePath("gameCam2")
self.gameNp2.setPos(0, -20, 0)
self.gameNp2.reparentTo(self.gameNp)
self.zoomMin = 0.0
self.zoomMax = 30.0
self.pMin = -89.999
self.pMax = 89.999
self.baseDx = 0.0
self.baseDy = 0.0
self.dragging = False
self.ratio = self.game.getAspectRatio()
self.mode = "3rd" # 3rd person view
self.mouse_y_inverted = False
self.mouse_x_inverted = False
self.sensivity = 1.0
#self.start_3rd()
self.request("ViewRPG")
def __init__(self, name):
FSM.state = '_Off' # Hacky bug fix for Panda3D 1.11.
FSM.__init__(self, name)
PandaNode.__init__(self, name)
DirectObject.__init__(self)
self.active = True
self.lastClickState = PGButton.SReady
self.clickState = PGButton.SReady
self.__hovering = False
self.clickEvent = ''
self.clickExtraArgs = []
self.contents = NodePath.anyPath(self).attachNewNode('contents')
# Create a MouseWatcherRegion:
self.regionName = self.getUniqueName() + '-region'
self.region = MouseWatcherRegion(self.regionName, 0, 0, 0, 0)
base.mouseWatcherNode.addRegion(self.region)
# Accept the mouse events:
enterPattern = base.mouseWatcherNode.getEnterPattern()
leavePattern = base.mouseWatcherNode.getLeavePattern()
buttonDownPattern = base.mouseWatcherNode.getButtonDownPattern()
buttonUpPattern = base.mouseWatcherNode.getButtonUpPattern()
self.accept(enterPattern.replace('%r', self.regionName),
self.__handleMouseEnter)
self.accept(leavePattern.replace('%r', self.regionName),
self.__handleMouseLeave)
self.accept(buttonDownPattern.replace('%r', self.regionName),
self.__handleMouseDown)
self.accept(buttonUpPattern.replace('%r', self.regionName),
self.__handleMouseUp)
def __init__(self, air, bldg, numSeats=4, antiShuffle=0, minLaff=0):
DistributedObjectAI.DistributedObjectAI.__init__(self, air)
FSM.__init__(self, "Elevator_%s_FSM" % (self.id))
self.type = ELEVATOR_NORMAL
self.countdownTime = ElevatorData[self.type]['countdown']
self.bldg = bldg
self.bldgDoId = bldg.getDoId()
self.seats = []
for seat in range(numSeats):
self.seats.append(None)
#self.seats = [None, None, None, None]
# Flag that tells whether the elevator is currently accepting boarders
self.accepting = 0
#self.setupStates()
#self.fsm.enterInitialState()
self.setAntiShuffle(antiShuffle)
self.setMinLaff(minLaff)
if self.antiShuffle:
if not hasattr(simbase.air, "elevatorTripId"):
simbase.air.elevatorTripId = 1
self.elevatorTripId = simbase.air.elevatorTripId
simbase.air.elevatorTripId += 1
else:
self.elevatorTripId = 0
def defaultFilter(self, request, args):
if request == self.state:
return None
else:
return FSM.defaultFilter(self, request, args)
return None
def __init__(self, activity):
FSM.__init__(self, self.__class__.__name__)
self.activity = activity
