class KartGlobals: ENTER_MOVIE = 1 EXIT_MOVIE = 2 COUNTDOWN_TIME = 30 BOARDING_TIME = 10.0 ENTER_RACE_TIME = 6.0 ERROR_CODE = PythonUtil.Enum( 'success, eGeneric, eTickets, eBoardOver, eNoKart, eOccupied, eTrackClosed, eTooLate, eUnpaid' ) FRONT_LEFT_SPOT = 0 FRONT_RIGHT_SPOT = 1 REAR_LEFT_SPOT = 2 REAR_RIGHT_SPOT = 3 PAD_GROUP_NUM = 4 def getPadLocation(padId): return padId % KartGlobals.PAD_GROUP_NUM getPadLocation = staticmethod(getPadLocation)
(40, 50, 60, 70, 300), (60, 80, 100, 120, 500), (100, 130, 160, 190, 800), (160, 210, 260, 310, 1300), (260, 340, 420, 500, 2100), (420, 550, 680, 810, 3400), (680, 890, 1100, 1310, 5500, 680, 5500, 680, 890, 1100, 1310, 5500, 680, 890, 1100, 1310, 1520, 1730, 1940, 2150, 2360, 5500, 680, 890, 1100, 1310, 1520, 1730, 1940, 2150, 2360, 5500, 680, 890, 1100, 1310, 1520, 1730, 1940, 2150, 2360, 5500, 0), (160, 210, 260, 310, 1300), (260, 340, 420, 500, 2100), (420, 550, 680, 810, 3400), (680, 890, 1100, 1310, 5500), (1100, 1440, 1780, 2120, 8900), (1780, 2330, 2880, 34300, 14400), (2880, 3770, 4660, 5500, 23300), (4660, 6100, 7540, 8930, 37700, 4660, 37700, 4660, 6100, 7540, 8930, 37700, 4660, 6100, 7540, 8930, 10420, 11860, 13300, 14740, 16180, 37700, 4660, 6100, 7540, 8930, 10420, 11860, 13300, 14740, 16180, 37700, 4660, 6100, 7540, 8930, 10420, 11860, 13300, 14740, 16180, 37700, 0)) suitTypes = PythonUtil.Enum(('NoSuit', 'NoMerits', 'FullSuit')) def getNextPart(parts, partIndex, dept): dept = dept2deptIndex(dept) suitBitMask = PartsPerSuitBitmasks[dept] queryMask = PartsQueryMasks[partIndex] needMask = queryMask & suitBitMask parts = parts[dept] haveMask = parts & queryMask nextPart = ~needMask | haveMask nextPart = nextPart ^ nextPart + 1 nextPart = nextPart + 1 >> 1 return nextPart def getPartName(partArray):
class CogdoFlyingObstacle(DirectObject): EnterEventName = 'CogdoFlyingObstacle_Enter' ExitEventName = 'CogdoFlyingObstacle_Exit' MotionTypes = PythonUtil.Enum(('BackForth', 'Loop')) def __init__(self, type, index, model, collSolid, motionPath=None, motionPattern=None, blendMotion=True, instanceModel=True): self.type = type self.index = index name = 'CogdoFlyingObstacle-%s-%i' % (self.type, self.index) if instanceModel: self.model = NodePath(name) model.instanceTo(self.model) else: self.model = model self.model.setName(name) self.currentT = 0.0 self.direction = 1.0 self.collNode = None self._initCollisions(name, collSolid) self.motionPath = motionPath self.motionPattern = motionPattern self.motionSequence = None if blendMotion: blendType = 'easeInOut' else: blendType = 'noBlend' if motionPath is not None: def moveObstacle(value): self.motionPath.goTo(self.model, value) self.motionPath = Mopath.Mopath(name='obstacle-%i' % self.index) self.motionPath.loadNodePath(motionPath) dur = self.motionPath.getMaxT() self.motionSequence = Sequence( name='%s.obstacle-%i-motionSequence' % (self.__class__.__name__, self.index)) movePart1 = LerpFunc(moveObstacle, fromData=0.0, toData=self.motionPath.getMaxT(), duration=dur, blendType=blendType) self.motionSequence.append(movePart1) if self.motionPattern == CogdoFlyingObstacle.MotionTypes.BackForth: movePart2 = LerpFunc(moveObstacle, fromData=self.motionPath.getMaxT(), toData=0.0, duration=dur, blendType=blendType) self.motionSequence.append(movePart2) def _initCollisions(self, name, collSolid): self.collName = name self.collSolid = collSolid self.collSolid.setTangible(0) self.collNode = CollisionNode(self.collName) self.collNode.setIntoCollideMask(ToontownGlobals.WallBitmask) self.collNode.addSolid(self.collSolid) self.collNodePath = self.model.attachNewNode(self.collNode) self.collNodePath.hide() self.accept('enter' + self.collName, self._handleEnterCollision) self.accept('exit' + self.collName, self._handleExitCollision) def disable(self): if self.collNode is not None: self.collNode.setIntoCollideMask(BitMask32(0)) def enable(self): if self.collNode is not None: self.collNode.setIntoCollideMask(ToontownGlobals.WallBitmask) def startMoving(self, elapsedTime=0.0): if self.motionSequence is not None: self.motionSequence.loop() self.motionSequence.setT(elapsedTime % self.motionSequence.getDuration()) def stopMoving(self): if self.motionSequence is not None: self.motionSequence.pause() def destroy(self): self.ignoreAll() if self.motionSequence is not None: self.motionSequence.clearToInitial() del self.motionSequence del self.collSolid self.collNodePath.removeNode() del self.collNodePath del self.collNode self.model.removeNode() del self.model del self.motionPath def update(self, dt): pass def hide(self): self.ignoreAll() self.model.hide() self.collNode.setIntoCollideMask(BitMask32(0)) def _handleEnterCollision(self, collEntry): messenger.send(CogdoFlyingObstacle.EnterEventName, [self, collEntry]) def _handleExitCollision(self, collEntry): messenger.send(CogdoFlyingObstacle.ExitEventName, [self, collEntry])
from pandac.PandaModules import * from direct.interval.IntervalGlobal import * from toontown.toonbase import ToonPythonUtil as PythonUtil from toontown.battle.BattleProps import globalPropPool from direct.directnotify import DirectNotifyGlobal SFX = PythonUtil.Enum('poof, magic') SFXPATHS = { SFX.poof: 'phase_4/audio/sfx/firework_distance_02.ogg', SFX.magic: 'phase_4/audio/sfx/SZ_DD_treasure.ogg' } class DustCloud(NodePath): dustCloudCount = 0 sounds = {} notify = DirectNotifyGlobal.directNotify.newCategory('DustCloud') def __init__(self, parent=hidden, fBillboard=1, wantSound=0): NodePath.__init__(self) self.assign(globalPropPool.getProp('suit_explosion_dust')) if fBillboard: self.setBillboardAxis() self.reparentTo(parent) self.seqNode = self.find('**/+SequenceNode').node() self.seqNode.setFrameRate(0) self.wantSound = wantSound if self.wantSound and not DustCloud.sounds: DustCloud.sounds[SFX.poof] = loader.loadSfx(SFXPATHS[SFX.poof]) self.track = None self.trackId = DustCloud.dustCloudCount DustCloud.dustCloudCount += 1
PartyEditorGridBounds[0][0] + (PartyEditorGridBounds[1][0] - PartyEditorGridBounds[0][0]) / 2.0, PartyEditorGridBounds[1][1] + (PartyEditorGridBounds[0][1] - PartyEditorGridBounds[1][1]) / 2.0) PartyEditorGridSize = (18, 15) PartyEditorGridSquareSize = ( (PartyEditorGridBounds[1][0] - PartyEditorGridBounds[0][0]) / float(PartyEditorGridSize[0]), (PartyEditorGridBounds[0][1] - PartyEditorGridBounds[1][1]) / float(PartyEditorGridSize[1])) PartyEditorGridRotateThreshold = 0.08 AvailableGridSquares = 202 TrashCanPosition = (-0.24, 0.0, -0.65) TrashCanScale = 0.7 PartyEditorTrashBounds = ((-0.16, -0.38), (-0.05, -0.56)) ActivityRequestStatus = PythonUtil.Enum(('Joining', 'Exiting')) InviteStatus = PythonUtil.Enum( ('NotRead', 'ReadButNotReplied', 'Accepted', 'Rejected')) InviteTheme = PythonUtil.Enum( ('Birthday', 'GenericMale', 'GenericFemale', 'Racing', 'Valentoons', 'VictoryParty', 'Winter')) PartyStatus = PythonUtil.Enum(('Pending', 'Cancelled', 'Finished', 'CanStart', 'Started', 'NeverStarted')) AddPartyErrorCode = PythonUtil.Enum( ('AllOk', 'ValidationError', 'DatabaseError', 'TooManyHostedParties')) ChangePartyFieldErrorCode = PythonUtil.Enum( ('AllOk', 'ValidationError', 'DatabaseError', 'AlreadyStarted', 'AlreadyRefunded')) ActivityTypes = PythonUtil.Enum( ('HostInitiated', 'GuestInitiated', 'Continuous')) PartyGateDenialReasons = PythonUtil.Enum(('Unavailable', 'Full'))
from toontown.toonbase import ToonPythonUtil as PythonUtil from pandac.PandaModules import VBase4, Vec3, Point3 from toontown.cogdominium.CogdoUtil import VariableContainer, DevVariableContainer AI = VariableContainer() AI.GameActions = PythonUtil.Enum( ('LandOnWinPlatform', 'WinStateFinished', 'GotoWinState', 'HitWhirlwind', 'HitLegalEagle', 'HitMinion', 'DebuffInvul', 'RequestEnterEagleInterest', 'RequestExitEagleInterest', 'RanOutOfTimePenalty', 'Died', 'Spawn', 'SetBlades', 'BladeLost')) AI.BroadcastPeriod = 0.3 AI.SafezoneId2DeathDamage = { 2000: 1, 1000: 2, 5000: 4, 4000: 8, 3000: 12, 9000: 16 } AI.SafezoneId2WhirlwindDamage = { 2000: 1, 1000: 2, 5000: 4, 4000: 8, 3000: 12, 9000: 16 } AI.SafezoneId2LegalEagleDamage = { 2000: 2,
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): self.doodleChat = base.config.GetBool('want-doodle-chat', False) Avatar.Avatar.__init__(self) self.serialNum = Pet.SerialNum Pet.SerialNum += 1 self.lockedDown = 0 self.setPickable(1) self.setPlayerType(NametagGlobals.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) def getDNA(self): return self.style def setDNA(self, dna): if self.style: pass else: self.style = dna self.generatePet() self.initializeDropShadow() self.initializeNametag3d() self.generateMoods() 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() 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): nodePath = NodePath(self.nametag.getNameIcon()) if not nodePath: return moodIcons = loader.loadModel('phase_4/models/char/petEmotes') self.moodIcons = nodePath.attachNewNode('moodIcons') self.moodIcons.setScale(6.0) self.moodIcons.setZ(3.5) moods = moodIcons.findAllMatches('**/+GeomNode') for moodNum in xrange(0, moods.getNumPaths()): mood = moods.getPath(moodNum) mood.reparentTo(self.moodIcons) mood.setBillboardPointEye() mood.hide() moodIcons.removeNode() def clearMood(self): if self.moodModel: self.moodModel.hide() self.moodModel = None return def showMood(self, mood): #if base.cr.newsManager.isHolidayRunning(ToontownGlobals.APRIL_TOONS_WEEK) and mood != 'confusion': if self.doodleChat and mood != 'confusion': self.speakMood(mood) 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() self.moodModel.setScale(0, 0, 0) Sequence( self.moodModel.scaleInterval(.2, VBase3(1.1, 1.1, 1.1), blendType = 'easeInOut'), self.moodModel.scaleInterval(.09, VBase3(1, 1, 1), blendType = 'easeInOut')).start() return def speakMood(self, mood): self.setChatAbsolute(random.choice(TTLocalizer.SpokenMoods[mood]), CFSpeech) 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
#Embedded file name: toontown.cogdominium.CogdoMazeGameGlobals from toontown.toonbase import ToonPythonUtil as PythonUtil from pandac.PandaModules import VBase4 GameActions = PythonUtil.Enum( ('EnterDoor', 'RevealDoor', 'OpenDoor', 'Countdown', 'TimeAlert')) SecondsUntilTimeout = 240.0 SecondsUntilGameEnds = 60.0 SecondsForTimeAlert = 60.0 MaxPlayers = 4 IntroDurationSeconds = 24.0 FinishDurationSeconds = 5.0 PlayerCollisionName = 'CogdoMazePlayer_Collision' LocalPlayerCollisionName = 'CogdoMazeLocalPlayer_Collision' PlayerCollisionRadius = 1.0 HitCooldownTime = 2.0 HintTimeout = 6.0 NumQuadrants = (3, 3) FrameWallThickness = 1 QuadrantUnitGap = 3 TotalBarriers = 12 NumBarriers = 3 MazeBarriers = ([(7, 34), (8, 34), (9, 34), (10, 34)], [(24, 34), (25, 34), (26, 34), (27, 34)], [(41, 34), (42, 34), (43, 34), (44, 34)], [(7, 17), (8, 17), (9, 17), (10, 17)], [(24, 17), (25, 17), (26, 17), (27, 17)], [(41, 17), (42, 17), (43, 17),
from toontown.toonbase import ToonPythonUtil as PythonUtil from otp.speedchat.SCMenu import SCMenu from otp.speedchat.SCMenuHolder import SCMenuHolder from otp.speedchat.SCStaticTextTerminal import SCStaticTextTerminal from otp.otpbase import OTPLocalizer JellybeanJamMenu = [(OTPLocalizer.JellybeanJamMenuSections[0], [30180, 30181, 30182, 30183, 30184, 30185]), (OTPLocalizer.JellybeanJamMenuSections[1], [30186, 30187, 30188, 30189, 30190])] JellybeanJamPhases = PythonUtil.Enum('TROLLEY, FISHING, PARTIES') PhaseSpecifPhrases = [30180, 30181, 30182] class TTSCJellybeanJamMenu(SCMenu): def __init__(self, phase): SCMenu.__init__(self) if phase in JellybeanJamPhases: self.__messagesChanged(phase) else: print 'warning: tried to add Jellybean Jam phase %s which does not seem to exist' % phase def destroy(self): SCMenu.destroy(self) def clearMenu(self): SCMenu.clearMenu(self) def __messagesChanged(self, phase): self.clearMenu() try: lt = base.localAvatar
from direct.directnotify import DirectNotifyGlobal from direct.gui.DirectGui import * from pandac.PandaModules import * from toontown.toonbase import ToonPythonUtil as PythonUtil from direct.task import Task from toontown.fishing.FishPhoto import DirectRegion from toontown.shtiker.ShtikerPage import ShtikerPage from toontown.toonbase import ToontownGlobals, TTLocalizer from FishPage import FishingTrophy from toontown.golf import GolfGlobals if (__debug__): import pdb PageMode = PythonUtil.Enum('Records, Trophy') class GolfPage(ShtikerPage): notify = DirectNotifyGlobal.directNotify.newCategory('GolfPage') def __init__(self): ShtikerPage.__init__(self) self.avatar = None self.mode = PageMode.Trophy return def enter(self): if not hasattr(self, 'title'): self.load() self.setMode(self.mode, 1) ShtikerPage.enter(self) def exit(self):
#Embedded file name: toontown.racing.KartDNA from direct.directnotify import DirectNotifyGlobal from toontown.toonbase import ToonPythonUtil as PythonUtil from toontown.toonbase import TTLocalizer from pandac.PandaModules import * from toontown.racing.KartShopGlobals import * import types import copy KartDNA = PythonUtil.Enum( 'bodyType, bodyColor, accColor, ebType, spType, fwwType, bwwType, rimsType, decalType' ) InvalidEntry = -1 KartInfo = PythonUtil.Enum( 'name, model, cost, viewDist, decalId, LODmodel1, LODmodel2') AccInfo = PythonUtil.Enum('name, model, cost, texCard, attach') kNames = TTLocalizer.KartDNA_KartNames KartDict = { 0: (kNames[0], 'phase_6/models/karting/Kart1_Final', 100, 7.0, 'kart1', 'phase_6/models/karting/Kart1_LOD_Final', 'phase_6/models/karting/Kart1_LOD_Final', (Point3(1.5, 8.0, -0.5), Point3(1.5, 0.0, 2.0))), 1: (kNames[1], 'phase_6/models/karting/Kart2_Final', 7500, 7.0, 'kart2', 'phase_6/models/karting/Kart2_LOD2_Final', 'phase_6/models/karting/Kart2_LOD3_Final', (Point3(0.25, 7, -2), Point3(1.25, -3, 0))), 2: (kNames[2], 'phase_6/models/karting/Kart3_Final', 2500, 8.5, 'kart3', 'phase_6/models/karting/Kart3_Final_LOD2', 'phase_6/models/karting/Kart3_Final_LOD3', (Point3(1.25, 4.0, 1.0), Point3(1.25, -3.0, 2.5))) } aNames = TTLocalizer.KartDNA_AccNames
class CogdoFlyingLocalPlayer(CogdoFlyingPlayer): notify = DirectNotifyGlobal.directNotify.newCategory('CogdoFlyingLocalPlayer') BroadcastPosTask = 'CogdoFlyingLocalPlayerBroadcastPos' PlayWaitingMusicEventName = 'PlayWaitingMusicEvent' RanOutOfTimeEventName = 'RanOutOfTimeEvent' PropStates = PythonUtil.Enum(('Normal', 'Overdrive', 'Off')) def __init__(self, toon, game, level, guiMgr): CogdoFlyingPlayer.__init__(self, toon) self.defaultTransitions = {'Inactive': ['FreeFly', 'Running'], 'FreeFly': ['Inactive', 'OutOfTime', 'Death', 'FlyingUp', 'Running', 'HitWhileFlying', 'InWhirlwind'], 'FlyingUp': ['Inactive', 'OutOfTime', 'Death', 'FreeFly', 'Running', 'HitWhileFlying', 'InWhirlwind'], 'InWhirlwind': ['Inactive', 'OutOfTime', 'Death', 'FreeFly', 'HitWhileFlying'], 'HitWhileFlying': ['Inactive', 'OutOfTime', 'Death', 'FreeFly', 'InWhirlwind'], 'Death': ['Inactive', 'OutOfTime', 'Spawn'], 'Running': ['Inactive', 'OutOfTime', 'FreeFly', 'FlyingUp', 'Refuel', 'WaitingForWin', 'HitWhileRunning'], 'HitWhileRunning': ['Inactive', 'OutOfTime', 'Death', 'Running', 'FreeFly'], 'Spawn': ['Inactive', 'OutOfTime', 'Running', 'WaitingForWin'], 'OutOfTime': ['Inactive', 'Spawn'], 'WaitingForWin': ['Inactive', 'Win'], 'Win': ['Inactive']} self.game = game self._level = level self._guiMgr = guiMgr self._inputMgr = CogdoFlyingInputManager() self._cameraMgr = CogdoFlyingCameraManager(camera, render, self, self._level) self.velocity = Vec3(0.0, 0.0, 0.0) self.instantaneousVelocity = Vec3(0.0, 0.0, 0.0) self.controlVelocity = Vec3(0.0, 0.0, 0.0) self.fanVelocity = Vec3(0.0, 0.0, 0.0) self.activeFans = [] self.fansStillHavingEffect = [] self.fanIndex2ToonVelocity = {} self.legalEagleInterestRequest = {} self.activeWhirlwind = None self.oldPos = Vec3(0.0, 0.0, 0.0) self.checkpointPlatform = None self.isHeadInCeiling = False self.isToonOnFloor = False self.fuel = 0.0 self.score = 0 self.postSpawnState = 'Running' self.didTimeRunOut = False self.hasPressedCtrlYet = False self.hasPickedUpFirstPropeller = False self.surfacePoint = None self.legalEagleHitting = False self.propState = None self.broadcastPeriod = Globals.AI.BroadcastPeriod self.initSfx() self.initLocalPlayerIntervals() self.initCollisions() self.initOrthoWalker() self.playerNumber = -1 self.fuel = 0.0 self._guiMgr.setFuel(self.fuel) self.setCheckpointPlatform(self._level.startPlatform) def initSfx(self): audioMgr = base.cogdoGameAudioMgr self._deathSfx = audioMgr.createSfx('death') self._hitByWhirlwindSfx = audioMgr.createSfx('toonInWhirlwind') self._bladeBreakSfx = audioMgr.createSfx('bladeBreak') self._collideSfx = audioMgr.createSfx('collide') self._toonHitSfx = audioMgr.createSfx('toonHit') self._getMemoSfx = audioMgr.createSfx('getMemo') self._getLaffSfx = audioMgr.createSfx('getLaff') self._getRedTapeSfx = audioMgr.createSfx('getRedTape') self._refuelSfx = audioMgr.createSfx('refuel') self._fanSfx = audioMgr.createSfx('fan') self._invulDebuffSfx = audioMgr.createSfx('invulDebuff') self._invulBuffSfx = audioMgr.createSfx('invulBuff') self._winSfx = audioMgr.createSfx('win') self._loseSfx = audioMgr.createSfx('lose') self._refuelSpinSfx = audioMgr.createSfx('refuelSpin') self._propellerSfx = audioMgr.createSfx('propeller', self.toon) def destroySfx(self): del self._deathSfx del self._hitByWhirlwindSfx del self._bladeBreakSfx del self._collideSfx del self._toonHitSfx del self._propellerSfx del self._getMemoSfx del self._getLaffSfx del self._refuelSfx del self._fanSfx del self._invulBuffSfx del self._invulDebuffSfx del self._getRedTapeSfx del self._refuelSpinSfx def setPlayerNumber(self, num): self.playerNumber = num def getPlayerNumber(self): return self.playerNumber def initOrthoWalker(self): orthoDrive = OrthoDrive(9.778, maxFrameMove=0.5, wantSound=True) self.orthoWalk = OrthoWalk(orthoDrive, broadcast=False, collisions=False, broadcastPeriod=Globals.AI.BroadcastPeriod) def initLocalPlayerIntervals(self): self.coolDownAfterHitInterval = Sequence(Wait(Globals.Gameplay.HitCooldownTime), Func(self.setEnemyHitting, False), name='coolDownAfterHitInterval-%i' % self.toon.doId) self.deathInterval = Sequence(Func(self.resetVelocities), Parallel(Parallel(Func(self._deathSfx.play), LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)), LerpFunctionInterval(self.toon.setScale, fromData=1.0, toData=0.1, duration=1.0), self.toon.posInterval(0.5, Vec3(0, 0, -25), other=self.toon)), Sequence(Wait(0.5), Func(base.transitions.irisOut))), Func(self.toon.stash), Wait(1.0), Func(self.toonSpawnFunc), name='%s.deathInterval' % self.__class__.__name__) self.outOfTimeInterval = Sequence(Func(messenger.send, CogdoFlyingLocalPlayer.PlayWaitingMusicEventName), Func(self._loseSfx.play), Func(base.transitions.irisOut), Wait(1.0), Func(self.resetVelocities), Func(self._guiMgr.setMessage, '', transition=None), Func(self.toon.stash), Func(self.toonSpawnFunc), name='%s.outOfTimeInterval' % self.__class__.__name__) self.spawnInterval = Sequence(Func(self.resetToonFunc), Func(self._cameraMgr.update, 0.0), Func(self._level.update), Func(self.toon.cnode.broadcastPosHprFull), Func(base.transitions.irisIn), Wait(0.5), Func(self.toon.setAnimState, 'TeleportIn'), Func(self.toon.unstash), Wait(1.5), Func(self.requestPostSpawnState), name='%s.spawnInterval' % self.__class__.__name__) self.waitingForWinInterval = Sequence(Func(self._guiMgr.setMessage, TTLocalizer.CogdoFlyingGameWaiting % '.'), Wait(1.5), Func(self._guiMgr.setMessage, TTLocalizer.CogdoFlyingGameWaiting % '..'), Wait(1.5), Func(self._guiMgr.setMessage, TTLocalizer.CogdoFlyingGameWaiting % '...'), Wait(1.5), name='%s.waitingForWinInterval' % self.__class__.__name__) self.waitingForWinSeq = Sequence(Func(self.setWaitingForWinState), Wait(4.0), Func(self.removeAllMemos), Wait(2.0), Func(self.game.distGame.d_sendRequestAction, Globals.AI.GameActions.LandOnWinPlatform, 0), Func(self.playWaitingForWinInterval), name='%s.waitingForWinSeq' % self.__class__.__name__) self.winInterval = Sequence(Func(self._guiMgr.setMessage, ''), Wait(4.0), Func(self.game.distGame.d_sendRequestAction, Globals.AI.GameActions.WinStateFinished, 0), name='%s.winInterval' % self.__class__.__name__) self.goSadSequence = Sequence(Wait(2.5), Func(base.transitions.irisOut, 1.5), name='%s.goSadSequence' % self.__class__.__name__) self.introGuiSeq = Sequence(Wait(0.5), Parallel(Func(self._guiMgr.setTemporaryMessage, TTLocalizer.CogdoFlyingGameMinimapIntro, duration=5.0), Sequence(Wait(1.0), Func(self._guiMgr.presentProgressGui))), Wait(5.0), Func(self._guiMgr.setMessage, TTLocalizer.CogdoFlyingGamePickUpAPropeller), name='%s.introGuiSeq' % self.__class__.__name__) def goSad(self): self.goSadSequence.start() def setWaitingForWinState(self): if self.didTimeRunOut: self.toon.b_setAnimState('Sad') self._guiMgr.setMessage(TTLocalizer.CogdoFlyingGameOutOfTime, transition='blink') else: self._winSfx.play() messenger.send(CogdoFlyingLocalPlayer.PlayWaitingMusicEventName) self.toon.b_setAnimState('victory') self._guiMgr.setMessage(TTLocalizer.CogdoFlyingGameYouMadeIt) def removeAllMemos(self): if self.didTimeRunOut: messenger.send(CogdoFlyingLocalPlayer.RanOutOfTimeEventName) def playWaitingForWinInterval(self): if not self.game.distGame.isSinglePlayer(): self.waitingForWinInterval.loop() def resetToonFunc(self): self.resetToon(resetFuel=self.hasPickedUpFirstPropeller) def _loopPropellerSfx(self, playRate = 1.0, volume = 1.0): self._propellerSfx.loop(playRate=playRate, volume=1.0) def initCollisions(self): avatarRadius = 2.0 reach = 4.0 self.flyerCollisions = CogdoFlyingCollisions() self.flyerCollisions.setWallBitMask(OTPGlobals.WallBitmask) self.flyerCollisions.setFloorBitMask(OTPGlobals.FloorBitmask) self.flyerCollisions.initializeCollisions(base.cTrav, self.toon, avatarRadius, OTPGlobals.FloorOffset, reach) self.flyerCollisions.setCollisionsActive(0) floorColl = CogdoFlyingPlatform.FloorCollName ceilingColl = CogdoFlyingPlatform.CeilingCollName self.accept('Flyer.cHeadCollSphere-enter-%s' % ceilingColl, self.__handleHeadCollisionIntoCeiling) self.accept('Flyer.cHeadCollSphere-exit-%s' % ceilingColl, self.__handleHeadCollisionExitCeiling) self.accept('Flyer.cFloorEventSphere-exit-%s' % floorColl, self.__handleEventCollisionExitFloor) self.accept('Flyer.cRayNode-enter-%s' % floorColl, self.__handleRayCollisionEnterFloor) self.accept('Flyer.cRayNode-again-%s' % floorColl, self.__handleRayCollisionAgainFloor) def enable(self): CogdoFlyingPlayer.enable(self) self.toon.hideName() def disable(self): CogdoFlyingPlayer.disable(self) def isLegalEagleInterestRequestSent(self, index): if index in self.legalEagleInterestRequest: return True return False def setLegalEagleInterestRequest(self, index): if index not in self.legalEagleInterestRequest: self.legalEagleInterestRequest[index] = True else: CogdoFlyingLocalPlayer.notify.warning('Attempting to set an legal eagle interest request when one already exists:%s' % index) def clearLegalEagleInterestRequest(self, index): if index in self.legalEagleInterestRequest: del self.legalEagleInterestRequest[index] def setBackpackState(self, state): if state == self.backpackState: return CogdoFlyingPlayer.setBackpackState(self, state) if state in Globals.Gameplay.BackpackStates: if state == Globals.Gameplay.BackpackStates.Normal: messenger.send(CogdoFlyingGuiManager.ClearMessageDisplayEventName) elif state == Globals.Gameplay.BackpackStates.Targeted: messenger.send(CogdoFlyingGuiManager.EagleTargetingLocalPlayerEventName) elif state == Globals.Gameplay.BackpackStates.Attacked: messenger.send(CogdoFlyingGuiManager.EagleAttackingLocalPlayerEventName) def requestPostSpawnState(self): self.request(self.postSpawnState) def toonSpawnFunc(self): self.game.distGame.b_toonSpawn(self.toon.doId) def __handleHeadCollisionIntoCeiling(self, collEntry): self.isHeadInCeiling = True self.surfacePoint = self.toon.getPos() self._collideSfx.play() if self.controlVelocity[2] > 0.0: self.controlVelocity[2] = -self.controlVelocity[2] / 2.0 def __handleHeadCollisionExitCeiling(self, collEntry): self.isHeadInCeiling = False self.surfacePoint = None def landOnPlatform(self, collEntry): surfacePoint = collEntry.getSurfacePoint(render) intoNodePath = collEntry.getIntoNodePath() platform = CogdoFlyingPlatform.getFromNode(intoNodePath) if platform is not None: if not platform.isStartOrEndPlatform(): taskMgr.doMethodLater(0.5, self.delayedLandOnPlatform, 'delayedLandOnPlatform', extraArgs=[platform]) elif platform.isEndPlatform(): taskMgr.doMethodLater(1.0, self.delayedLandOnWinPlatform, 'delayedLandOnWinPlatform', extraArgs=[platform]) self.isToonOnFloor = True self.controlVelocity = Vec3(0.0, 0.0, 0.0) self.toon.setPos(render, surfacePoint) self.toon.setHpr(0, 0, 0) self.request('Running') def __handleRayCollisionEnterFloor(self, collEntry): fromNodePath = collEntry.getFromNodePath() intoNodePath = collEntry.getIntoNodePath() intoName = intoNodePath.getName() fromName = fromNodePath.getName() toonPos = self.toon.getPos(render) collPos = collEntry.getSurfacePoint(render) if toonPos.getZ() < collPos.getZ() + Globals.Gameplay.RayPlatformCollisionThreshold: if not self.isToonOnFloor and self.state in ['FreeFly', 'FlyingUp']: self.landOnPlatform(collEntry) def __handleRayCollisionAgainFloor(self, collEntry): fromNodePath = collEntry.getFromNodePath() intoNodePath = collEntry.getIntoNodePath() intoName = intoNodePath.getName() fromName = fromNodePath.getName() toonPos = self.toon.getPos(render) collPos = collEntry.getSurfacePoint(render) if toonPos.getZ() < collPos.getZ() + Globals.Gameplay.RayPlatformCollisionThreshold: if not self.isToonOnFloor and self.state in ['FreeFly', 'FlyingUp']: self.landOnPlatform(collEntry) def __handleEventCollisionExitFloor(self, collEntry): fromNodePath = collEntry.getFromNodePath() intoNodePath = collEntry.getIntoNodePath() intoName = intoNodePath.getName() fromName = fromNodePath.getName() if self.isToonOnFloor: self.notify.debug('~~~Exit Floor:%s -> %s' % (intoName, fromName)) self.isToonOnFloor = False taskMgr.remove('delayedLandOnPlatform') taskMgr.remove('delayedLandOnWinPlatform') if self.state not in ['FlyingUp', 'Spawn']: self.notify.debug('Exited floor') self.request('FreeFly') def delayedLandOnPlatform(self, platform): self.setCheckpointPlatform(platform) return Task.done def delayedLandOnWinPlatform(self, platform): self.setCheckpointPlatform(self._level.endPlatform) self.request('WaitingForWin') return Task.done def handleTimerExpired(self): if self.state not in ['WaitingForWin', 'Win']: self.setCheckpointPlatform(self._level.endPlatform) self.postSpawnState = 'WaitingForWin' self.didTimeRunOut = True if self.state not in ['Death']: self.request('OutOfTime') def ready(self): self.resetToon(resetFuel=False) self._cameraMgr.enable() self._cameraMgr.update() def start(self): CogdoFlyingPlayer.start(self) self.toon.collisionsOff() self.flyerCollisions.setAvatar(self.toon) self.flyerCollisions.setCollisionsActive(1) self._levelBounds = self._level.getBounds() self.introGuiSeq.start() self.request('Running') def exit(self): self.request('Inactive') CogdoFlyingPlayer.exit(self) self._cameraMgr.disable() self.flyerCollisions.setCollisionsActive(0) self.flyerCollisions.setAvatar(None) taskMgr.remove('delayedLandOnFuelPlatform') taskMgr.remove('delayedLandOnWinPlatform') self.ignoreAll() def unload(self): self.toon.showName() self.toon.collisionsOn() self._destroyEventIval() self._destroyEnemyHitIval() CogdoFlyingPlayer.unload(self) self._fanSfx.stop() self.flyerCollisions.deleteCollisions() del self.flyerCollisions self.ignoreAll() taskMgr.remove('delayedLandOnPlatform') taskMgr.remove('delayedLandOnWinPlatform') self.checkpointPlatform = None self._cameraMgr.disable() del self._cameraMgr del self.game self._inputMgr.destroy() del self._inputMgr self.introGuiSeq.clearToInitial() del self.introGuiSeq if self.goSadSequence: self.goSadSequence.clearToInitial() del self.goSadSequence if self.coolDownAfterHitInterval: self.coolDownAfterHitInterval.clearToInitial() del self.coolDownAfterHitInterval if self.deathInterval: self.deathInterval.clearToInitial() del self.deathInterval if self.spawnInterval: self.spawnInterval.clearToInitial() del self.spawnInterval if self.outOfTimeInterval: self.outOfTimeInterval.clearToInitial() del self.outOfTimeInterval if self.winInterval: self.winInterval.clearToInitial() del self.winInterval if self.waitingForWinInterval: self.waitingForWinInterval.clearToInitial() del self.waitingForWinInterval if self.waitingForWinSeq: self.waitingForWinSeq.clearToInitial() del self.waitingForWinSeq del self.activeFans[:] del self.fansStillHavingEffect[:] self.fanIndex2ToonVelocity.clear() self.orthoWalk.stop() self.orthoWalk.destroy() del self.orthoWalk self.destroySfx() def setCheckpointPlatform(self, platform): self.checkpointPlatform = platform def resetVelocities(self): self.fanVelocity = Vec3(0.0, 0.0, 0.0) self.controlVelocity = Vec3(0.0, 0.0, 0.0) self.velocity = Vec3(0.0, 0.0, 0.0) def resetToon(self, resetFuel = True): CogdoFlyingPlayer.resetToon(self) self.resetVelocities() del self.activeFans[:] del self.fansStillHavingEffect[:] self.fanIndex2ToonVelocity.clear() self._fanSfx.stop() spawnPos = self.checkpointPlatform.getSpawnPosForPlayer(self.getPlayerNumber(), render) self.activeWhirlwind = None self.toon.setPos(render, spawnPos) self.toon.setHpr(render, 0, 0, 0) if resetFuel: self.resetFuel() self.isHeadInCeiling = False self.isToonOnFloor = True def activateFlyingBroadcast(self): self.timeSinceLastPosBroadcast = 0.0 self.lastPosBroadcast = self.toon.getPos() self.lastHprBroadcast = self.toon.getHpr() toon = self.toon toon.d_clearSmoothing() toon.sendCurrentPosition() taskMgr.remove(self.BroadcastPosTask) taskMgr.add(self.doBroadcast, self.BroadcastPosTask) def shutdownFlyingBroadcast(self): taskMgr.remove(self.BroadcastPosTask) def doBroadcast(self, task): dt = globalClock.getDt() self.timeSinceLastPosBroadcast += dt if self.timeSinceLastPosBroadcast >= self.broadcastPeriod: self.timeSinceLastPosBroadcast = 0.0 self.toon.cnode.broadcastPosHprFull() return Task.cont def died(self, timestamp): self.request('Death') def spawn(self, timestamp): self.request('Spawn') def updateToonFlyingState(self, dt): leftPressed = self._inputMgr.arrowKeys.leftPressed() rightPressed = self._inputMgr.arrowKeys.rightPressed() upPressed = self._inputMgr.arrowKeys.upPressed() downPressed = self._inputMgr.arrowKeys.downPressed() jumpPressed = self._inputMgr.arrowKeys.jumpPressed() if not self.hasPressedCtrlYet and jumpPressed and self.isFuelLeft(): self.hasPressedCtrlYet = True messenger.send(CogdoFlyingGuiManager.FirstPressOfCtrlEventName) if jumpPressed and self.isFuelLeft(): if self.state == 'FreeFly' and self.isInTransition() == False: self.notify.debug('FreeFly -> FlyingUp') self.request('FlyingUp') elif self.state == 'FlyingUp' and self.isInTransition() == False: self.notify.debug('FlyingUp -> FreeFly') self.request('FreeFly') if leftPressed and not rightPressed: self.toon.setH(self.toon, Globals.Gameplay.ToonTurning['turningSpeed'] * dt) max = Globals.Gameplay.ToonTurning['maxTurningAngle'] if self.toon.getH() > max: self.toon.setH(max) elif rightPressed and not leftPressed: self.toon.setH(self.toon, -1.0 * Globals.Gameplay.ToonTurning['turningSpeed'] * dt) min = -1.0 * Globals.Gameplay.ToonTurning['maxTurningAngle'] if self.toon.getH() < min: self.toon.setH(min) def updateControlVelocity(self, dt): leftPressed = self._inputMgr.arrowKeys.leftPressed() rightPressed = self._inputMgr.arrowKeys.rightPressed() upPressed = self._inputMgr.arrowKeys.upPressed() downPressed = self._inputMgr.arrowKeys.downPressed() jumpPressed = self._inputMgr.arrowKeys.jumpPressed() if leftPressed: self.controlVelocity[0] -= Globals.Gameplay.ToonAcceleration['turning'] * dt if rightPressed: self.controlVelocity[0] += Globals.Gameplay.ToonAcceleration['turning'] * dt if upPressed: self.controlVelocity[1] += Globals.Gameplay.ToonAcceleration['forward'] * dt if downPressed: self.controlVelocity[2] -= Globals.Gameplay.ToonAcceleration['activeDropDown'] * dt self.controlVelocity[1] -= Globals.Gameplay.ToonAcceleration['activeDropBack'] * dt if jumpPressed and self.isFuelLeft(): self.controlVelocity[2] += Globals.Gameplay.ToonAcceleration['boostUp'] * dt minVal = -Globals.Gameplay.ToonVelMax['turning'] maxVal = Globals.Gameplay.ToonVelMax['turning'] if not leftPressed and not rightPressed or self.controlVelocity[0] > maxVal or self.controlVelocity[0] < minVal: x = self.dampenVelocityVal(self.controlVelocity[0], 'turning', 'turning', minVal, maxVal, dt) self.controlVelocity[0] = x minVal = -Globals.Gameplay.ToonVelMax['backward'] maxVal = Globals.Gameplay.ToonVelMax['forward'] if not upPressed and not downPressed or self.controlVelocity[1] > maxVal or self.controlVelocity[1] < minVal: y = self.dampenVelocityVal(self.controlVelocity[1], 'backward', 'forward', minVal, maxVal, dt) self.controlVelocity[1] = y if self.isFuelLeft(): minVal = -Globals.Gameplay.ToonVelMax['fall'] else: minVal = -Globals.Gameplay.ToonVelMax['fallNoFuel'] maxVal = Globals.Gameplay.ToonVelMax['boost'] if self.controlVelocity[2] > minVal: if (not self._inputMgr.arrowKeys.jumpPressed() or not self.isFuelLeft()) and not self.isToonOnFloor: self.controlVelocity[2] -= Globals.Gameplay.ToonAcceleration['fall'] * dt if self.controlVelocity[2] < 0.0 and self.isToonOnFloor: self.controlVelocity[2] = 0.0 minVal = -Globals.Gameplay.ToonVelMax['turning'] maxVal = Globals.Gameplay.ToonVelMax['turning'] self.controlVelocity[0] = clamp(self.controlVelocity[0], minVal, maxVal) minVal = -Globals.Gameplay.ToonVelMax['backward'] maxVal = Globals.Gameplay.ToonVelMax['forward'] self.controlVelocity[1] = clamp(self.controlVelocity[1], minVal, maxVal) if self.isFuelLeft(): minVal = -Globals.Gameplay.ToonVelMax['fall'] else: minVal = -Globals.Gameplay.ToonVelMax['fallNoFuel'] maxVal = Globals.Gameplay.ToonVelMax['boost'] self.controlVelocity[2] = clamp(self.controlVelocity[2], minVal, maxVal) def updateFanVelocity(self, dt): fanHeight = Globals.Gameplay.FanCollisionTubeHeight min = Globals.Gameplay.FanMinPower max = Globals.Gameplay.FanMaxPower powerRange = max - min for fan in self.activeFans: blowVec = fan.getBlowDirection() blowVec *= Globals.Gameplay.ToonAcceleration['fan'] * dt if Globals.Gameplay.UseVariableFanPower: distance = fan.model.getDistance(self.toon) power = math.fabs(distance / fanHeight - 1.0) * powerRange + min power = clamp(power, min, max) blowVec *= power if fan.index in self.fanIndex2ToonVelocity: fanVelocity = self.fanIndex2ToonVelocity[fan.index] fanVelocity += blowVec removeList = [] for fan in self.fansStillHavingEffect: if fan not in self.activeFans: blowVec = fan.getBlowDirection() blowVec *= Globals.Gameplay.ToonDeceleration['fan'] * dt if fan.index in self.fanIndex2ToonVelocity: fanVelocity = Vec3(self.fanIndex2ToonVelocity[fan.index]) lastLen = fanVelocity.length() fanVelocity -= blowVec if fanVelocity.length() > lastLen: removeList.append(fan) else: self.fanIndex2ToonVelocity[fan.index] = fanVelocity for fan in removeList: self.fansStillHavingEffect.remove(fan) if fan.index in self.fanIndex2ToonVelocity: del self.fanIndex2ToonVelocity[fan.index] self.fanVelocity = Vec3(0.0, 0.0, 0.0) for fan in self.fansStillHavingEffect: if fan.index in self.fanIndex2ToonVelocity: self.fanVelocity += self.fanIndex2ToonVelocity[fan.index] minVal = -Globals.Gameplay.ToonVelMax['fan'] maxVal = Globals.Gameplay.ToonVelMax['fan'] self.fanVelocity[0] = clamp(self.fanVelocity[0], minVal, maxVal) self.fanVelocity[1] = clamp(self.fanVelocity[1], minVal, maxVal) self.fanVelocity[2] = clamp(self.fanVelocity[2], minVal, maxVal) def dampenVelocityVal(self, velocityVal, typeNeg, typePos, minVal, maxVal, dt): if velocityVal > 0.0: velocityVal -= Globals.Gameplay.ToonDeceleration[typePos] * dt velocityVal = clamp(velocityVal, 0.0, maxVal) elif velocityVal < 0.0: velocityVal += Globals.Gameplay.ToonDeceleration[typeNeg] * dt velocityVal = clamp(velocityVal, minVal, 0.0) return velocityVal def allowFuelDeath(self): if Globals.Gameplay.DoesToonDieWithFuel: return True return not self.isFuelLeft() def updateToonPos(self, dt): toonWorldY = self.toon.getY(render) if self.hasPickedUpFirstPropeller == False: if toonWorldY > -7.6: self.toon.setY(-7.6) elif toonWorldY < -35.0: self.toon.setY(-35.0) return self.velocity = self.controlVelocity + self.fanVelocity vel = self.velocity * dt self.toon.setPos(self.toon, vel[0], vel[1], vel[2]) toonPos = self.toon.getPos() if Globals.Dev.DisableDeath: pass elif toonPos[2] < 0.0 and self.state in ['FreeFly', 'FlyingUp'] and self.allowFuelDeath(): self.postSpawnState = 'Running' self.game.distGame.b_toonDied(self.toon.doId) if toonPos[2] > self._levelBounds[2][1]: self.controlVelocity[2] = 0.0 self.fanVelocity[2] = 0.0 toonPos = Vec3(clamp(toonPos[0], self._levelBounds[0][0], self._levelBounds[0][1]), clamp(toonPos[1], self._levelBounds[1][0], self._levelBounds[1][1]), clamp(toonPos[2], self._levelBounds[2][0], self._levelBounds[2][1])) if self.isHeadInCeiling and toonPos[2] > self.surfacePoint[2]: toonPos[2] = self.surfacePoint[2] self.toon.setPos(toonPos) if self.toon.getY(render) < -10: self.toon.setY(-10.0) def printFanInfo(self, string): if len(self.fanIndex2ToonVelocity) > 0: self.notify.info('==AFTER %s==' % string) self.notify.info('Fan velocity:%s' % self.fanVelocity) if len(self.activeFans) > 0: self.notify.info('%s' % self.activeFans) if len(self.fanIndex2ToonVelocity) > 0: self.notify.info('%s' % self.fanIndex2ToonVelocity) if len(self.fansStillHavingEffect) > 0: self.notify.info('%s' % self.fansStillHavingEffect) def resetFuel(self): self.setFuel(Globals.Gameplay.FuelNormalAmt) def isFuelLeft(self): return self.fuel > 0.0 def setFuel(self, fuel): self.fuel = fuel self._guiMgr.setFuel(fuel) if self.fuel <= 0.0: fuelState = Globals.Gameplay.FuelStates.FuelEmpty elif self.fuel < Globals.Gameplay.FuelVeryLowAmt: fuelState = Globals.Gameplay.FuelStates.FuelVeryLow elif self.fuel < Globals.Gameplay.FuelLowAmt: fuelState = Globals.Gameplay.FuelStates.FuelLow else: fuelState = Globals.Gameplay.FuelStates.FuelNormal if fuelState > self.fuelState: self.game.distGame.b_toonSetBlades(self.toon.doId, fuelState) if fuelState < self.fuelState: if self.state in ['FlyingUp', 'FreeFly', 'Running']: self.game.distGame.b_toonBladeLost(self.toon.doId) def resetBlades(self): CogdoFlyingPlayer.resetBlades(self) self._guiMgr.resetBlades() def setBlades(self, fuelState): CogdoFlyingPlayer.setBlades(self, fuelState) self._guiMgr.setBlades(fuelState) def bladeLost(self): CogdoFlyingPlayer.bladeLost(self) self._bladeBreakSfx.play(volume=0.35) self._guiMgr.bladeLost() def updateFuel(self, dt): if Globals.Dev.InfiniteFuel: self.setFuel(Globals.Gameplay.FuelNormalAmt) elif self.state in Globals.Gameplay.DepleteFuelStates and self.fuel > 0.0: self.setFuel(self.fuel - Globals.Gameplay.FuelBurnRate * dt) elif self.fuel < 0.0: self.setFuel(0.0) def update(self, dt = 0.0): self.instantaneousVelocity = (self.toon.getPos() - self.oldPos) / dt self.oldPos = self.toon.getPos() self.updateFuel(dt) if self.isFlying(): self.updateToonFlyingState(dt) if self.state in ['FreeFly', 'FlyingUp', 'Death']: self.updateControlVelocity(dt) self.updateFanVelocity(dt) self.updateToonPos(dt) self._cameraMgr.update(dt) def isFlying(self): if self.state in ['FreeFly', 'FlyingUp']: return True return False def pressedControlWhileRunning(self): if self.isFuelLeft() and self.state == 'Running': self.notify.debug('Pressed Control and have fuel') self.request('FlyingUp') else: self.ignore(base.JUMP) self.acceptOnce(base.JUMP, self.pressedControlWhileRunning) def setPropellerState(self, propState): if not self.hasPickedUpFirstPropeller: propState = CogdoFlyingLocalPlayer.PropStates.Off if self.propState != propState: oldState = self.propState self.propState = propState if self.propState == CogdoFlyingLocalPlayer.PropStates.Normal: if not self.propellerSpinLerp.isPlaying(): self.propellerSpinLerp.loop() self.setPropellerSpinRate(Globals.Gameplay.NormalPropSpeed) self._guiMgr.setPropellerSpinRate(Globals.Gameplay.NormalPropSpeed) self._loopPropellerSfx(playRate=0.7, volume=0.8) elif self.propState == CogdoFlyingLocalPlayer.PropStates.Overdrive: if not self.propellerSpinLerp.isPlaying(): self.propellerSpinLerp.loop() self.setPropellerSpinRate(Globals.Gameplay.OverdrivePropSpeed) self._guiMgr.setPropellerSpinRate(Globals.Gameplay.OverdrivePropSpeed) self._loopPropellerSfx(playRate=1.1) elif self.propState == CogdoFlyingLocalPlayer.PropStates.Off: self.propellerSpinLerp.pause() self._propellerSfx.stop() def enterInactive(self): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self._inputMgr.disable() self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Off) self.shutdownFlyingBroadcast() def filterInactive(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitInactive(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) self._inputMgr.enable() self.activateFlyingBroadcast() def enterSpawn(self): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self.toon.b_setAnimState('Happy', 1.0) self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Normal) self.spawnInterval.start() def filterSpawn(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitSpawn(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) def enterFreeFly(self): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Normal) if self.oldState in ['Running', 'HitWhileRunning']: self.toon.jumpStart() self.toon.setHpr(render, 0, 0, 0) def filterFreeFly(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitFreeFly(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) def enterFlyingUp(self): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Overdrive) if self.oldState in ['Running']: self.toon.jumpStart() self.toon.setHpr(render, 0, 0, 0) def filterFlyingUp(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitFlyingUp(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) def enterHitWhileFlying(self, elapsedTime = 0.0): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self.setEnemyHitting(True) self._toonHitSfx.play() self.startHitFlyingToonInterval() self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Normal) def filterHitWhileFlying(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitHitWhileFlying(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) self.enemyHitIval.clearToInitial() self.coolDownAfterHitInterval.clearToInitial() self.coolDownAfterHitInterval.start() def enterInWhirlwind(self, elapsedTime = 0.0): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self._hitByWhirlwindSfx.play() self.startHitByWhirlwindInterval() self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Normal) def filterInWhirlwind(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitInWhirlwind(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) self.eventIval.clearToInitial() def enterHitWhileRunning(self, elapsedTime = 0.0): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self.setEnemyHitting(True) self._toonHitSfx.play() self.toon.b_setAnimState('FallDown') self.startHitRunningToonInterval() self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Normal) def filterHitWhileRunning(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitHitWhileRunning(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) self.enemyHitIval.clearToInitial() self.coolDownAfterHitInterval.clearToInitial() self.coolDownAfterHitInterval.start() def enterRunning(self): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self.toon.b_setAnimState('Happy', 1.0) if self.oldState not in ['Spawn', 'HitWhileRunning', 'Inactive']: self.toon.jumpHardLand() self._collideSfx.play() self.orthoWalk.start() self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Normal) self.ignore(base.JUMP) self.acceptOnce(base.JUMP, self.pressedControlWhileRunning) def filterRunning(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitRunning(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) self.orthoWalk.stop() self.ignore(base.JUMP) def enterOutOfTime(self): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) if self.spawnInterval.isPlaying(): self.spawnInterval.clearToInitial() self.ignoreAll() self.introGuiSeq.clearToInitial() self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Off) if not Globals.Dev.NoLegalEagleAttacks: for eagle in self.legalEaglesTargeting: messenger.send(CogdoFlyingLegalEagle.RequestRemoveTargetEventName, [eagle.index]) taskMgr.remove('delayedLandOnPlatform') taskMgr.remove('delayedLandOnWinPlatform') self.outOfTimeInterval.start() def filterOutOfTime(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitOutOfTime(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) def enterDeath(self): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self.propellerSmoke.stop() self.deathInterval.start() self.toon.b_setAnimState('jumpAirborne', 1.0) self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Off) if not Globals.Dev.NoLegalEagleAttacks: for eagle in self.legalEaglesTargeting: messenger.send(CogdoFlyingLegalEagle.RequestRemoveTargetEventName, [eagle.index]) def filterDeath(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitDeath(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) self.deathInterval.clearToInitial() def enterWaitingForWin(self): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self.resetFuel() self._guiMgr.hideRefuelGui() self.waitingForWinSeq.start() self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Normal) if not Globals.Dev.NoLegalEagleAttacks: self.game.forceClearLegalEagleInterestInToon(self.toon.doId) def filterWaitingForWin(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitWaitingForWin(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) self.waitingForWinSeq.finish() self.waitingForWinInterval.clearToInitial() def enterWin(self): CogdoFlyingLocalPlayer.notify.info("enter%s: '%s' -> '%s'" % (self.newState, self.oldState, self.newState)) self._guiMgr.stopTimer() self.winInterval.start() self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Normal) def filterWin(self, request, args): if request == self.state: return None else: return self.defaultFilter(request, args) return None def exitWin(self): CogdoFlyingLocalPlayer.notify.debug("exit%s: '%s' -> '%s'" % (self.oldState, self.oldState, self.newState)) def _destroyEventIval(self): if hasattr(self, 'eventIval'): self.eventIval.clearToInitial() del self.eventIval def startEventIval(self, ival): self._destroyEventIval() self.eventIval = ival self.eventIval.start() def _destroyEnemyHitIval(self): if hasattr(self, 'enemyHitIval'): self.enemyHitIval.clearToInitial() del self.enemyHitIval def startEnemyHitIval(self, ival): self._destroyEnemyHitIval() self.enemyHitIval = ival self.enemyHitIval.start() def isEnemyHitting(self): return self.legalEagleHitting def setEnemyHitting(self, value): self.legalEagleHitting = value def shouldLegalEagleBeInFrame(self): if not self.isLegalEagleTarget(): return False else: index = len(self.legalEaglesTargeting) - 1 eagle = self.legalEaglesTargeting[index] return eagle.shouldBeInFrame() def startHitRunningToonInterval(self): dur = self.toon.getDuration('slip-backward') self.startEnemyHitIval(Sequence(Wait(dur), Func(self.request, 'Running'), name='hitByLegalEagleIval-%i' % self.toon.doId)) def startHitFlyingToonInterval(self): hitByEnemyPos = self.toon.getPos(render) collVec = hitByEnemyPos - self.collPos collVec[2] = 0.0 collVec.normalize() collVec *= Globals.Gameplay.HitKnockbackDist def spinPlayer(t, rand): if rand == 0: self.toon.setH(-(t * 720.0)) else: self.toon.setH(t * 720.0) direction = random.randint(0, 1) self.startEnemyHitIval(Sequence(Parallel(LerpFunc(spinPlayer, fromData=0.0, toData=1.0, duration=Globals.Gameplay.HitKnockbackTime, blendType='easeInOut', extraArgs=[direction]), LerpPosInterval(self.toon, duration=Globals.Gameplay.HitKnockbackTime, pos=hitByEnemyPos + collVec, blendType='easeOut')), Func(self.request, 'FreeFly'), name='hitByLegalEagleIval-%i' % self.toon.doId)) def startHitByWhirlwindInterval(self): def spinPlayer(t): self.controlVelocity[2] = 1.0 angle = math.radians(t * (720.0 * 2 - 180)) self.toon.setPos(self.activeWhirlwind.model.getX(self.game.level.root) + math.cos(angle) * 2, self.activeWhirlwind.model.getY(self.game.level.root) + math.sin(angle) * 2, self.toon.getZ()) def movePlayerBack(t): self.toon.setY(self.activeWhirlwind.model.getY(self.game.level.root) - t * Globals.Gameplay.WhirlwindMoveBackDist) self.startEventIval(Sequence(Func(self._cameraMgr.freeze), Func(self.activeWhirlwind.disable), LerpFunc(spinPlayer, fromData=0.0, toData=1.0, duration=Globals.Gameplay.WhirlwindSpinTime), LerpFunc(movePlayerBack, fromData=0.0, toData=1.0, duration=Globals.Gameplay.WhirlwindMoveBackTime, blendType='easeOut'), Func(self.activeWhirlwind.enable), Func(self._cameraMgr.unfreeze), Func(self.request, 'FreeFly'), name='spinPlayerIval-%i' % self.toon.doId)) def handleEnterWhirlwind(self, whirlwind): self.activeWhirlwind = whirlwind self.request('InWhirlwind') def handleEnterEnemyHit(self, enemy, collPos): self.collPos = collPos if self.state in ['FlyingUp', 'FreeFly']: self.request('HitWhileFlying') elif self.state in ['Running']: self.request('HitWhileRunning') def handleEnterFan(self, fan): if fan in self.activeFans: return if len(self.activeFans) == 0: self._fanSfx.loop() self.activeFans.append(fan) if fan.index not in self.fanIndex2ToonVelocity: self.fanIndex2ToonVelocity[fan.index] = Vec3(0.0, 0.0, 0.0) if fan not in self.fansStillHavingEffect: self.fansStillHavingEffect.append(fan) def handleExitFan(self, fan): if fan in self.activeFans: self.activeFans.remove(fan) if len(self.activeFans) == 0: self._fanSfx.stop() def handleDebuffPowerup(self, pickupType, elapsedTime): self._invulDebuffSfx.play() CogdoFlyingPlayer.handleDebuffPowerup(self, pickupType, elapsedTime) messenger.send(CogdoFlyingGuiManager.ClearMessageDisplayEventName) def handleEnterGatherable(self, gatherable, elapsedTime): CogdoFlyingPlayer.handleEnterGatherable(self, gatherable, elapsedTime) if gatherable.type == Globals.Level.GatherableTypes.Memo: self.handleEnterMemo(gatherable) elif gatherable.type == Globals.Level.GatherableTypes.Propeller: self.handleEnterPropeller(gatherable) elif gatherable.type == Globals.Level.GatherableTypes.LaffPowerup: self.handleEnterLaffPowerup(gatherable) elif gatherable.type == Globals.Level.GatherableTypes.InvulPowerup: self.handleEnterInvulPowerup(gatherable) def handleEnterMemo(self, gatherable): self.score += 1 if self.score == 1: self._guiMgr.presentMemoGui() self._guiMgr.setTemporaryMessage(TTLocalizer.CogdoFlyingGameMemoIntro, 4.0) self._guiMgr.setMemoCount(self.score) self._getMemoSfx.play() def handleEnterPropeller(self, gatherable): if self.fuel < 1.0: if not self.hasPickedUpFirstPropeller: messenger.send(CogdoFlyingGuiManager.PickedUpFirstPropellerEventName) self.introGuiSeq.clearToInitial() self.hasPickedUpFirstPropeller = True self.setPropellerState(CogdoFlyingLocalPlayer.PropStates.Normal) self.setFuel(1.0) self._guiMgr.update() self._refuelSfx.play() self._refuelSpinSfx.play(volume=0.15) def handleEnterLaffPowerup(self, gatherable): self._getLaffSfx.play() def handleEnterInvulPowerup(self, gatherable): messenger.send(CogdoFlyingGuiManager.InvulnerableEventName) self._getRedTapeSfx.play()