Sneed-Group/Poodletooth-iLand
1
0
Fork 0
mirror of https://github.com/Sneed-Group/Poodletooth-iLand synced 2024-12-29 06:32:40 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions
Poodletooth-iLand/toontown/minigame/DistributedVineGame.py

1550 lines
64 KiB
Python
Raw Normal View History

Initial commit
2015-03-03 16:10:12 -06:00
from pandac.PandaModules import Point3, ForceNode, LinearVectorForce, CollisionHandlerEvent, CollisionNode, CollisionSphere, Camera, PerspectiveLens, Vec4, Point2, ActorNode, Vec3, BitMask32
from direct.interval.IntervalGlobal import Sequence, Parallel, Func, Wait, LerpPosInterval, ActorInterval, LerpScaleInterval, ProjectileInterval, SoundInterval
from direct.directnotify import DirectNotifyGlobal
from direct.gui.DirectFrame import DirectFrame
from direct.gui.DirectGui import DGG
from toontown.toonbase import ToontownGlobals
from direct.task.Task import Task
from direct.fsm import ClassicFSM, State
from toontown.toonbase import TTLocalizer
from toontown.minigame.DistributedMinigame import DistributedMinigame
from toontown.minigame import SwingVine
from toontown.minigame import ArrowKeys
from toontown.minigame import VineGameGlobals
from toontown.minigame import VineTreasure
from toontown.minigame import MinigameAvatarScorePanel
from toontown.toonbase import ToontownTimer
from toontown.minigame import VineHeadFrame
from toontown.minigame import VineBat
class DistributedVineGame(DistributedMinigame):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedVineGame')
UpdateLocalToonTask = 'VineGameUpdateLocalToonTask'
LocalPhysicsRadius = 1.5
Gravity = 32
ToonVerticalRate = 0.25
FallingNot = 0
FallingNormal = 1
FallingSpider = 2
FallingBat = 3
JumpingFrame = 128
ToonMaxRightFrame = 35
def __init__(self, cr):
DistributedMinigame.__init__(self, cr)
self.JumpSpeed = 64
self.TwoVineView = True
self.ArrowToChangeFacing = True
self.gameFSM = ClassicFSM.ClassicFSM('DistributedVineGame', [State.State('off', self.enterOff, self.exitOff, ['play']),
State.State('play', self.enterPlay, self.exitPlay, ['cleanup', 'showScores', 'waitShowScores']),
State.State('waitShowScores', self.enterWaitShowScores, self.exitWaitShowScores, ['cleanup', 'showScores']),
State.State('showScores', self.enterShowScores, self.exitShowScores, ['cleanup']),
State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup')
self.addChildGameFSM(self.gameFSM)
self.cameraTopView = (17.6, 6.18756, 43.9956, 0, -89, 0)
self.cameraThreeQuarterView = (0, -63.2, 16.3, 0, 0, 0)
self.cameraSidePos = Point3(0, -63.2, 16.3)
self.cameraTwoVineSidePos = Point3(0, -53, 17.3)
self.cameraTwoVineAdj = 5
self.cameraSideView = (-15, -53, 17.3, 0, 0, 0)
self.localPhysicsNP = None
self.vines = []
self.physicsHandler = None
self.lastJumpVine = -1
self.lastJumpPos = None
self.lastJumpT = 0
self.lastJumpFacingRight = True
self.lastJumpTime = 0
self.toonInfo = {}
self.otherToonPhysics = {}
self.headFrames = {}
self.changeFacingInterval = None
self.attachingToVineCamIval = None
self.localToonJumpAnimIval = None
self.endingTracks = {}
self.endingTrackTaskNames = []
self.sendNewVineTUpdateAsap = False
self.lastNewVineTUpdate = 0
self.defaultMaxX = (VineGameGlobals.NumVines + 1) * VineGameGlobals.VineXIncrement
return
def getClimbDir(self, avId):
retval = 0
if avId in self.toonInfo:
retval = self.toonInfo[avId][5]
return retval
def moveCameraToSide(self):
camera.reparentTo(render)
p = self.cameraSideView
camera.setPosHpr(p[0], p[1], p[2], p[3], p[4], p[5])
def getTitle(self):
return TTLocalizer.VineGameTitle
def getInstructions(self):
return TTLocalizer.VineGameInstructions
def getMaxDuration(self):
return 0
def defineConstants(self):
self.ShowToonSpheres = 0
def load(self):
self.notify.debug('load')
DistributedMinigame.load(self)
self.defineConstants()
self.music = base.loadMusic('phase_4/audio/bgm/MG_Vine.ogg')
self.gameAssets = loader.loadModel('phase_4/models/minigames/vine_game')
self.gameBoard = self.gameAssets.find('**/background')
self.gameBoard.reparentTo(render)
self.gameBoard.show()
self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0)
self.gameBoard.setTransparency(1)
self.gameBoard.setColorScale(1, 1, 1, 0.5)
self.gameBoard.setScale(1.0)
self.gameBoard.hide(VineGameGlobals.RadarCameraBitmask)
self.gameBoardL = self.gameBoard.copyTo(render)
self.gameBoardL.setPos(-635, 0, 0)
self.gameBoardR = self.gameBoard.copyTo(render)
self.gameBoardR.setPos(635, 0, 0)
self.treasureModel = self.gameAssets.find('**/bananas')
self.setupVineCourse()
self.grabSound = base.loadSfx('phase_4/audio/sfx/MG_sfx_vine_game_bananas.ogg')
self.jumpSound = base.loadSfx('phase_4/audio/sfx/MG_sfx_vine_game_jump.ogg')
self.catchSound = base.loadSfx('phase_4/audio/sfx/MG_sfx_vine_game_catch.ogg')
self.spiderHitSound = base.loadSfx('phase_4/audio/sfx/MG_sfx_vine_game_spider_hit.ogg')
self.batHitVineSound = base.loadSfx('phase_4/audio/sfx/MG_sfx_vine_game_bat_hit.ogg')
self.batHitMidairSound = base.loadSfx('phase_4/audio/sfx/MG_sfx_vine_game_bat_hit_midair.ogg')
self.winSound = base.loadSfx('phase_4/audio/sfx/MG_sfx_vine_game_finish.ogg')
self.fallSound = base.loadSfx('phase_4/audio/sfx/MG_sfx_vine_game_fall.ogg')
self.loadBats()
self.createBatIvals()
bothPlatform = loader.loadModel('phase_4/models/minigames/vine_game_shelf')
self.startPlatform = bothPlatform.find('**/start1')
self.startPlatform.setPos(-16, 0, 15)
self.startPlatform.reparentTo(render)
self.startPlatform.setScale(1.0, 1.0, 0.75)
self.endPlatform = bothPlatform.find('**/end1')
endPos = self.vines[VineGameGlobals.NumVines - 1].getPos()
self.endPlatform.setPos(endPos[0] + 20, 0, 15)
self.endPlatform.reparentTo(render)
self.endPlatform.setScale(1.0, 1.0, 0.75)
def unload(self):
self.notify.debug('unload')
DistributedMinigame.unload(self)
self.removeChildGameFSM(self.gameFSM)
del self.gameFSM
del self.music
self.gameAssets.removeNode()
self.gameBoard.removeNode()
self.gameBoardL.removeNode()
self.gameBoardR.removeNode()
del self.gameBoard
del self.gameBoardL
del self.gameBoardR
self.treasureModel.removeNode()
del self.treasureModel
for vine in self.vines:
vine.unload()
del vine
self.vines = []
self.destroyBatIvals()
for bat in self.bats:
bat.destroy()
del bat
self.bats = []
del self.grabSound
del self.jumpSound
del self.catchSound
del self.spiderHitSound
del self.batHitVineSound
del self.batHitMidairSound
del self.winSound
del self.fallSound
if self.localToonJumpAnimIval:
self.localToonJumpAnimIval.finish()
del self.localToonJumpAnimIval
self.startPlatform.removeNode()
self.endPlatform.removeNode()
def onstage(self):
self.notify.debug('onstage')
DistributedMinigame.onstage(self)
for avId in self.avIdList:
self.updateToonInfo(avId, vineIndex=0, vineT=VineGameGlobals.VineStartingT, posX=0, posZ=0, facingRight=0, climbDir=0, fallingInfo=self.FallingNot)
self.scorePanels = []
self.gameBoard.reparentTo(render)
self.moveCameraToSide()
self.arrowKeys = ArrowKeys.ArrowKeys()
handlers = [self.upArrowKeyHandler,
self.downArrowKeyHandler,
self.leftArrowKeyHandler,
self.rightArrowKeyHandler,
None]
self.arrowKeys.setPressHandlers(handlers)
self.numTreasures = len(self.vines) - 1
self.treasures = []
for i in xrange(self.numTreasures):
height = self.randomNumGen.randrange(10, 25)
xPos = self.randomNumGen.randrange(12, 18)
pos = Point3(self.vines[i].getX() + 15, 0, height)
self.treasures.append(VineTreasure.VineTreasure(self.treasureModel, pos, i, self.doId))
gravityFN = ForceNode('world-forces')
gravityFNP = render.attachNewNode(gravityFN)
gravityForce = LinearVectorForce(0, 0, -self.Gravity)
gravityFN.addForce(gravityForce)
base.physicsMgr.addLinearForce(gravityForce)
self.gravityForce = gravityForce
self.gravityForceFNP = gravityFNP
lt = base.localAvatar
radius = 0.7
handler = CollisionHandlerEvent()
handler.setInPattern('ltCatch-%fn')
self.bodyColEventNames = []
self.ltLegsCollNode = CollisionNode('catchLegsCollNode')
self.bodyColEventNames.append('ltCatch-%s' % 'catchLegsCollNode')
self.ltLegsCollNode.setCollideMask(VineGameGlobals.SpiderBitmask)
self.ltTorsoCollNode = CollisionNode('catchTorsoCollNode')
self.bodyColEventNames.append('ltCatch-%s' % 'catchTorsoCollNode')
self.ltTorsoCollNode.setCollideMask(VineGameGlobals.SpiderBitmask)
self.ltHeadCollNode = CollisionNode('catchHeadCollNode')
self.bodyColEventNames.append('ltCatch-%s' % 'catchHeadCollNode')
self.ltHeadCollNode.setCollideMask(VineGameGlobals.SpiderBitmask)
self.ltLHandCollNode = CollisionNode('catchLHandCollNode')
self.bodyColEventNames.append('ltCatch-%s' % 'catchLHandCollNode')
self.ltLHandCollNode.setCollideMask(VineGameGlobals.SpiderBitmask)
self.ltRHandCollNode = CollisionNode('catchRHandCollNode')
self.bodyColEventNames.append('ltCatch-%s' % 'catchRHandCollNode')
self.ltRHandCollNode.setCollideMask(VineGameGlobals.SpiderBitmask)
legsCollNodepath = lt.attachNewNode(self.ltLegsCollNode)
legsCollNodepath.hide()
head = base.localAvatar.getHeadParts().getPath(2)
headCollNodepath = head.attachNewNode(self.ltHeadCollNode)
headCollNodepath.hide()
torso = base.localAvatar.getTorsoParts().getPath(2)
torsoCollNodepath = torso.attachNewNode(self.ltTorsoCollNode)
torsoCollNodepath.hide()
self.torso = torsoCollNodepath
lHand = base.localAvatar.getLeftHands()[0]
lHandCollNodepath = lHand.attachNewNode(self.ltLHandCollNode)
lHandCollNodepath.hide()
rHand = base.localAvatar.getRightHands()[0]
rHandCollNodepath = rHand.attachNewNode(self.ltRHandCollNode)
rHandCollNodepath.hide()
lt.cTrav.addCollider(legsCollNodepath, handler)
lt.cTrav.addCollider(headCollNodepath, handler)
lt.cTrav.addCollider(lHandCollNodepath, handler)
lt.cTrav.addCollider(rHandCollNodepath, handler)
lt.cTrav.addCollider(torsoCollNodepath, handler)
if self.ShowToonSpheres:
legsCollNodepath.show()
headCollNodepath.show()
lHandCollNodepath.show()
rHandCollNodepath.show()
torsoCollNodepath.show()
self.ltLegsCollNode.addSolid(CollisionSphere(0, 0, radius, radius))
self.ltHeadCollNode.addSolid(CollisionSphere(0, 0, 0, radius))
self.ltLHandCollNode.addSolid(CollisionSphere(0, 0, 0, 2 * radius / 3.0))
self.ltRHandCollNode.addSolid(CollisionSphere(0, 0, 0, 2 * radius / 3.0))
self.ltTorsoCollNode.addSolid(CollisionSphere(0, 0, radius, radius * 2))
self.toonCollNodes = [legsCollNodepath,
headCollNodepath,
lHandCollNodepath,
rHandCollNodepath,
torsoCollNodepath]
for eventName in self.bodyColEventNames:
self.accept(eventName, self.toonHitSomething)
self.introTrack = self.getIntroTrack()
self.introTrack.start()
return
def offstage(self):
self.notify.debug('offstage')
for panel in self.scorePanels:
panel.cleanup()
del self.scorePanels
self.gameBoard.hide()
DistributedMinigame.offstage(self)
self.arrowKeys.destroy()
del self.arrowKeys
for avId in self.avIdList:
av = self.getAvatar(avId)
if av:
av.dropShadow.show()
av.resetLOD()
for treasure in self.treasures:
treasure.destroy()
del self.treasures
base.physicsMgr.removeLinearForce(self.gravityForce)
self.gravityForceFNP.removeNode()
for collNode in self.toonCollNodes:
while collNode.node().getNumSolids():
collNode.node().removeSolid(0)
base.localAvatar.cTrav.removeCollider(collNode)
del self.toonCollNodes
for eventName in self.bodyColEventNames:
self.ignore(eventName)
self.ignoreAll()
if self.introTrack.isPlaying():
self.introTrack.finish()
del self.introTrack
for vine in self.vines:
vine.stopSwing()
vine.hide()
self.startPlatform.hide()
self.endPlatform.hide()
def handleDisabledAvatar(self, avId):
self.notify.debug('handleDisabledAvatar')
self.notify.debug('avatar ' + str(avId) + ' disabled')
DistributedMinigame.handleDisabledAvatar(self, avId)
def updateToonInfo(self, avId, vineIndex = None, vineT = None, posX = None, posZ = None, facingRight = None, climbDir = None, velX = None, velZ = None, fallingInfo = None):
newVineIndex = vineIndex
newVineT = vineT
newPosX = posX
newPosZ = posZ
newFacingRight = facingRight
newClimbDir = climbDir
newVelX = velX
newVelZ = velZ
newFallingInfo = fallingInfo
oldInfo = None
if avId in self.toonInfo:
oldInfo = self.toonInfo[avId]
if vineIndex == None:
newVineIndex = oldInfo[0]
if vineT == None:
newVineT = oldInfo[1]
if posX == None:
newPosX = oldInfo[2]
if posZ == None:
newPosZ = oldInfo[3]
if facingRight == None:
newFacingRight = oldInfo[4]
if climbDir == None:
newClimbDir = oldInfo[5]
if velX == None:
newVelX = oldInfo[6]
if velZ == None:
newVelZ = oldInfo[7]
if fallingInfo == None:
newFallingInfo = oldInfo[8]
if newVineIndex < -1 or newVineIndex >= len(self.vines):
self.notify.warning('invalid vineIndex for %d, forcing 0' % avId)
newVineIndex = 0
if newVineT < 0 or newVineT > 1:
self.notify.warning('invalid vineT for %d, setting to 0' % avId)
if not (newFacingRight == 0 or newFacingRight == 1):
self.notify.warning('invalid facingRight for %d, forcing to 1' % avId)
newFacingRight = 1
if newPosX < -1000 or newPosX > 2000:
self.notify.warning('invalid posX for %d, forcing to 0' % avId)
newPosX = 0
if newPosZ < -100 or newPosZ > 1000:
self.notify.warning('invalid posZ for %d, forcing to 0' % avId)
newPosZ = 0
if newVelX < -1000 or newVelX > 1000:
self.notify.warning('invalid velX %s for %d, forcing to 0' % (newVelX, avId))
newVelX = 0
if newVelZ < -1000 or newVelZ > 1000:
self.notify.warning('invalid velZ %s for %d, forcing to 0' % (newVelZ, avId))
newVelZ = 0
if newFallingInfo < self.FallingNot or newFallingInfo > self.FallingBat:
self.notify.warning('invalid fallingInfo for %d, forcing to 0' % avId)
newFallingInfo = 0
newInfo = [newVineIndex,
newVineT,
newPosX,
newPosZ,
newFacingRight,
newClimbDir,
newVelX,
newVelZ,
newFallingInfo]
self.toonInfo[avId] = newInfo
if oldInfo:
self.applyToonInfoChange(avId, newInfo, oldInfo)
self.sanityCheck()
return
def applyToonInfoChange(self, avId, newInfo, oldInfo):
if not self.isInPlayState():
return
oldVine = oldInfo[0]
newVine = newInfo[0]
if not oldVine == newVine:
self.notify.debug('we have a vine change')
if oldVine == -1:
self.notify.debug(' we were jumping and now attaching to a new vine')
newVineT = newInfo[1]
newFacingRight = newInfo[4]
self.vines[newVine].attachToon(avId, newVineT, newFacingRight)
if newVine == VineGameGlobals.NumVines - 1:
self.doEndingTrackTask(avId)
elif newVine == -1:
self.notify.debug('we were attached to a vine and we are now jumping')
curInfo = self.vines[oldVine].getAttachedToonInfo(avId)
self.vines[oldVine].detachToon(avId)
if not avId == self.localAvId:
posX = newInfo[2]
posZ = newInfo[3]
velX = newInfo[6]
velZ = newInfo[7]
self.makeOtherToonJump(avId, posX, posZ, velX, velZ)
else:
self.notify.warning('should not happen directly going from one vine to another')
self.vines[oldVine].detachToon(avId)
newVineT = newInfo[1]
newFacingRight = newInfo[4]
self.vines[newVine].attachToon(avId, newVineT, newFacingRight)
elif newVine == oldVine and newInfo[4] != oldInfo[4]:
self.notify.debug('# still on the same vine, but we changed facing')
self.vines[newVine].changeAttachedToonFacing(avId, newInfo[4])
elif newVine >= 0:
self.vines[newVine].changeAttachedToonT(avId, newInfo[1])
else:
self.notify.debug('we are still falling')
if oldInfo[8] != newInfo[8]:
if not avId == self.localAvId:
posX = newInfo[2]
posZ = newInfo[3]
velX = newInfo[6]
velZ = newInfo[7]
self.makeOtherToonFallFromMidair(avId, posX, posZ, velX, velZ)
def sanityCheck(self):
if not self.isInPlayState():
return
for avId in self.toonInfo.keys():
myVineIndex = self.toonInfo[avId][0]
foundVines = []
foundVineIndex = -1
for curVine in xrange(len(self.vines)):
curInfo = self.vines[curVine].getAttachedToonInfo(avId)
if curInfo:
foundVines.append(curVine)
foundVineIndex = curVine
if len(foundVines) > 1:
self.notify.warning('toon %d is attached to vines %s' % (avId, foundVines))
if not foundVineIndex == myVineIndex and not myVineIndex == VineGameGlobals.NumVines - 1:
self.notify.warning('avId=%d foundVineIndex=%d != myVineIndex=%d' % (avId, foundVineIndex, myVineIndex))
def getVineAndVineInfo(self, avId):
retVine = -1
retInfo = None
for curVine in xrange(len(self.vines)):
curInfo = self.vines[curVine].getAttachedToonInfo(avId)
if curInfo:
retVine = curVine
retInfo = curInfo
break
if self.toonInfo[avId][0] != retVine:
self.notify.warning("getVineAndVineInfo don't agree, toonInfo[%d]=%s, retVine=%d" % (avId, self.toonInfo[avId][0], retVine))
return (retVine, curInfo)
def setGameReady(self):
if not self.hasLocalToon:
return
self.notify.debug('setGameReady')
if DistributedMinigame.setGameReady(self):
return
self.toonOffsets = {}
self.toonOffsetsFalling = {}
for index in xrange(self.numPlayers):
avId = self.avIdList[index]
toon = self.getAvatar(avId)
if toon:
toon.reparentTo(render)
toon.setPos(0, 0, 0)
toon.setHpr(0, 0, 0)
self.toonOffsets[avId] = self.calcToonOffset(toon)
toon.dropShadow.hide()
newHeadFrame = VineHeadFrame.VineHeadFrame(toon)
newHeadFrame.hide()
self.headFrames[avId] = newHeadFrame
toon.useLOD(1000)
toon.setX(-100)
def calcToonOffset(self, toon):
offset = Point3(0, 0, 0)
toon.pose('swing', 74)
leftHand = toon.find('**/leftHand')
if not leftHand.isEmpty():
offset = leftHand.getPos(toon)
return offset
def setGameStart(self, timestamp):
if not self.hasLocalToon:
return
self.notify.debug('setGameStart')
DistributedMinigame.setGameStart(self, timestamp)
if self.introTrack.isPlaying():
self.introTrack.finish()
self.gameFSM.request('play')
def enterOff(self):
self.notify.debug('enterOff')
def exitOff(self):
pass
def enterPlay(self):
self.notify.debug('enterPlay')
if base.localAvatar.laffMeter:
base.localAvatar.laffMeter.stop()
self.createRadar()
self.scores = [0] * self.numPlayers
spacing = 0.4
for i in xrange(self.numPlayers):
avId = self.avIdList[i]
avName = self.getAvatarName(avId)
scorePanel = MinigameAvatarScorePanel.MinigameAvatarScorePanel(avId, avName)
scorePanel.setScale(0.9)
scorePanel.setPos(-0.583 - spacing * (self.numPlayers - 1 - i), 0.0, -0.15)
scorePanel.reparentTo(base.a2dTopRight)
scorePanel.makeTransparent(0.75)
self.scorePanels.append(scorePanel)
for vine in self.vines:
vine.show()
vine.startSwing()
self.startBatIvals()
for avId in self.avIdList:
toon = self.getAvatar(avId)
if toon:
if avId == self.localAvId:
self.attachLocalToonToVine(0, VineGameGlobals.VineStartingT)
else:
self.vines[0].attachToon(avId, VineGameGlobals.VineStartingT, self.lastJumpFacingRight)
self.timer = ToontownTimer.ToontownTimer()
self.timer.posInTopRightCorner()
self.timer.setTime(VineGameGlobals.GameDuration)
self.timer.countdown(VineGameGlobals.GameDuration, self.timerExpired)
base.playMusic(self.music, looping=1, volume=0.9)
self.__spawnUpdateLocalToonTask()
def exitPlay(self):
self.notify.debug('exitPlay')
if base.localAvatar.laffMeter:
base.localAvatar.laffMeter.start()
self.timer.stop()
self.timer.destroy()
del self.timer
self.clearLocalPhysics()
for ival in self.batIvals:
ival.finish()
del ival
self.batIvals = []
self.music.stop()
def enterWaitShowScores(self):
self.notify.debug('enterWaitShowScores')
def exitWaitShowScores(self):
self.notify.debug('exitWaitShowScores')
def enterShowScores(self):
self.notify.debug('enterShowScores')
lerpTrack = Parallel()
lerpDur = 0.5
tY = 0.6
bY = -.05
lX = -.5
cX = 0
rX = 0.5
scorePanelLocs = (((cX, bY),),
((lX, bY), (rX, bY)),
((cX, tY), (lX, bY), (rX, bY)),
((lX, tY),
(rX, tY),
(lX, bY),
(rX, bY)))
scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
panel.wrtReparentTo(aspect2d)
lerpTrack.append(Parallel(LerpPosInterval(panel, lerpDur, Point3(pos[0], 0, pos[1]), blendType='easeInOut'), LerpScaleInterval(panel, lerpDur, Vec3(panel.getScale()) * 2.0, blendType='easeInOut')))
self.showScoreTrack = Parallel(lerpTrack, Sequence(Wait(VineGameGlobals.ShowScoresDuration), Func(self.gameOver)))
self.showScoreTrack.start()
def exitShowScores(self):
self.showScoreTrack.pause()
del self.showScoreTrack
def enterCleanup(self):
self.notify.debug('enterCleanup')
self.destroyRadar()
self.__killUpdateLocalToonTask()
self.cleanupEndingTracks()
for avId in self.headFrames:
self.headFrames[avId].destroy()
def exitCleanup(self):
pass
def __spawnUpdateLocalToonTask(self):
taskMgr.remove(self.UpdateLocalToonTask)
taskMgr.add(self.__updateLocalToonTask, self.UpdateLocalToonTask)
def __killUpdateLocalToonTask(self):
taskMgr.remove(self.UpdateLocalToonTask)
def clearLocalPhysics(self):
if self.localPhysicsNP:
an = self.localPhysicsNP.node()
base.physicsMgr.removePhysicalNode(an)
self.localPhysicsNP.removeNode()
del self.localPhysicsNP
self.localPhysicsNP = None
if hasattr(self, 'treasureCollNodePath') and self.treasureCollNodePath:
self.treasureCollNodePath.removeNode()
return
def handleLocalToonFellDown(self):
self.notify.debug('attaching toon back to vine since he fell')
self.fallSound.play()
vineToAttach = self.lastJumpVine
if self.toonInfo[self.localAvId][8] == self.FallingSpider:
if self.vines[vineToAttach].hasSpider:
vineToAttach -= 1
if vineToAttach < 0:
vineToAttach = 0
self.attachLocalToonToVine(vineToAttach, VineGameGlobals.VineFellDownT)
def makeCameraFollowJumpingToon(self):
camera.setHpr(0, 0, 0)
if self.TwoVineView:
camera.setPos(self.cameraTwoVineSidePos)
maxVine = self.lastJumpVine + 1
if maxVine >= len(self.vines):
maxVine = len(self.vines) - 1
maxX = self.defaultMaxX
if self.vines:
maxX = self.vines[maxVine].getX()
minVine = self.lastJumpVine - 1
if minVine < 0:
minVine = 0
minX = 0
if self.vines:
minX = self.vines[minVine].getX()
camera.setX(base.localAvatar.getX(render))
if camera.getX() > maxX:
camera.setX(maxX)
if camera.getX() < minX:
camera.setX(minX)
else:
camera.setPos(self.cameraSidePos)
maxVine = self.lastJumpVine + 1
if maxVine >= len(self.vines):
maxVine = len(self.vines) - 1
maxX = self.vines[maxVine].getX()
minVine = self.lastJumpVine - 1
if minVine < 0:
minVine = 0
minX = self.vines[minVine].getX()
camera.setX(base.localAvatar.getX(render))
if camera.getX() > maxX:
camera.setX(maxX)
if camera.getX() < minX:
camera.setX(minX)
def __updateOtherToonsClimbing(self):
for avId in self.toonInfo.keys():
if avId == self.localAvId:
continue
toonInfo = self.toonInfo[avId]
vineIndex = toonInfo[0]
if vineIndex == -1:
continue
climbDir = toonInfo[5]
if climbDir == None or climbDir == 0:
continue
curT = toonInfo[1]
dt = globalClock.getDt()
diffT = 0
baseVerticalRate = self.ToonVerticalRate
if climbDir == -1:
diffT -= baseVerticalRate * dt
if climbDir == 1:
diffT += baseVerticalRate * dt
newT = curT + diffT
if newT > 1:
newT = 1
if newT < 0:
newT = 0
if not newT == curT:
toonInfo[1] = newT
self.vines[vineIndex].changeAttachedToonT(avId, newT)
return
def __updateLocalToonTask(self, task):
dt = globalClock.getDt()
self.updateRadar()
self.__updateOtherToonsClimbing()
for bat in self.bats:
bat.checkScreech()
if self.localPhysicsNP:
pos = self.localPhysicsNP.getPos(render)
if pos[2] < 0:
self.handleLocalToonFellDown()
avId = self.localAvId
curInfo = None
for vineIndex in xrange(len(self.vines)):
curInfo = self.vines[vineIndex].getAttachedToonInfo(avId)
if curInfo:
break
if not curInfo:
if avId not in self.endingTracks:
self.makeCameraFollowJumpingToon()
if self.localPhysicsNP:
pos = self.localPhysicsNP.getPos(render)
else:
curT = curInfo[0]
diffT = 0
baseVerticalRate = self.ToonVerticalRate
onEndVine = vineIndex == len(self.vines) - 1
if self.arrowKeys.upPressed() and not onEndVine and self.isInPlayState():
diffT -= baseVerticalRate * dt
if self.arrowKeys.downPressed() and not onEndVine and self.isInPlayState():
diffT += baseVerticalRate * dt
newT = curT + diffT
if newT > 1:
newT = 1
if newT < 0:
newT = 0
oldClimbDir = self.getClimbDir(avId)
climbDir = 0
if diffT < 0:
climbDir = -1
elif diffT > 0:
climbDir = 1
if not newT == curT:
self.vines[vineIndex].changeAttachedToonT(avId, newT)
if newT != curT or self.getClimbDir(avId) and not curT == 1.0 or oldClimbDir != climbDir:
if oldClimbDir != climbDir:
self.sendNewVineTUpdateAsap = True
self.b_setNewVineT(avId, newT, climbDir)
return task.cont
def setupCollisions(self, anp):
fromObject = anp.attachNewNode(CollisionNode('colNode'))
fromObject.node().addSolid(CollisionSphere(0, 0, 0, self.LocalPhysicsRadius))
fromCollideMask = ToontownGlobals.PieBitmask
self.notify.debug('fromCollideMask = %s' % fromCollideMask)
fromObject.node().setFromCollideMask(fromCollideMask)
self.handler = CollisionHandlerEvent()
self.handler.addInPattern('%fn-into')
base.cTrav.setRespectPrevTransform(True)
base.cTrav.addCollider(fromObject, self.handler)
eventName = '%s-into' % fromObject.getName()
self.accept(eventName, self.swingVineEnter)
height = base.localAvatar.getHeight()
self.treasureSphereName = 'treasureCollider'
center = Point3(0, 0, 0)
radius = VineTreasure.VineTreasure.RADIUS
self.treasureCollSphere = CollisionSphere(center[0], center[1], center[2], radius)
self.treasureCollSphere.setTangible(0)
self.treasureCollNode = CollisionNode(self.treasureSphereName)
self.treasureCollNode.setFromCollideMask(ToontownGlobals.WallBitmask)
self.treasureCollNode.addSolid(self.treasureCollSphere)
self.treasureCollNodePath = self.torso.attachNewNode(self.treasureCollNode)
self.treasureHandler = CollisionHandlerEvent()
self.treasureHandler.addInPattern('%fn-intoTreasure')
base.cTrav.addCollider(self.treasureCollNodePath, self.treasureHandler)
eventName = '%s-intoTreasure' % self.treasureCollNodePath.getName()
self.notify.debug('eventName = %s' % eventName)
self.accept(eventName, self.treasureEnter)
def getFocusCameraPos(self, vineIndex, facingRight):
retPos = Point3(0, 0, 0)
if self.TwoVineView:
pos = self.vines[vineIndex].getPos()
retPos = Point3(self.cameraTwoVineSidePos)
if vineIndex == 0:
nextVinePos = self.vines[vineIndex + 1].getPos()
newX = (pos.getX() + nextVinePos.getX()) / 2.0
newX -= self.cameraTwoVineAdj
retPos.setX(newX)
elif vineIndex == VineGameGlobals.NumVines - 1:
nextVinePos = self.vines[vineIndex].getPos()
nextVinePos.setX(nextVinePos.getX() + VineGameGlobals.VineXIncrement)
newX = (pos.getX() + nextVinePos.getX()) / 2.0
newX += self.cameraTwoVineAdj
retPos.setX(newX)
else:
otherVineIndex = vineIndex - 1
if self.lastJumpFacingRight:
otherVineIndex = vineIndex + 1
nextVinePos = self.vines[otherVineIndex].getPos()
newX = (pos.getX() + nextVinePos.getX()) / 2.0
if self.lastJumpFacingRight:
newX -= self.cameraTwoVineAdj
else:
newX += self.cameraTwoVineAdj
retPos.setX(newX)
else:
pos = self.vines[vineIndex].getPos()
retPos.setX(pos.getX())
self.notify.debug('getFocusCameraPos returning %s' % retPos)
return retPos
def focusCameraOnVine(self, vineIndex):
camera.setHpr(0, 0, 0)
newCameraPos = self.getFocusCameraPos(vineIndex, self.lastJumpFacingRight)
camera.setPos(newCameraPos)
def attachLocalToonToVine(self, vineIndex, vineT, focusCameraImmediately = True, playSfx = False):
self.notify.debug('focusCameraImmediately = %s' % focusCameraImmediately)
if playSfx:
self.catchSound.play()
self.clearLocalPhysics()
vine = self.vines[vineIndex]
self.lastJumpVine = -1
self.lastJumpPos = None
self.lastJumpT = 0
if focusCameraImmediately:
self.focusCameraOnVine(vineIndex)
self.b_setNewVine(self.localAvId, vineIndex, vineT, self.lastJumpFacingRight)
return
def setupJumpingTransitionIval(self, vineIndex):
self.doingJumpTransition = False
self.localToonJumpAnimIval = self.createJumpingTransitionIval(vineIndex)
if self.localToonJumpAnimIval:
self.doingJumpTransition = True
def createJumpingTransitionIval(self, vineIndex):
retval = None
curInfo = self.vines[vineIndex].getAttachedToonInfo(base.localAvatar.doId)
if curInfo:
swingSeq = curInfo[6]
if swingSeq:
curFrame = -1
for i in xrange(len(swingSeq)):
self.notify.debug('testing actor interval i=%d' % i)
actorIval = swingSeq[i]
if not actorIval.isStopped():
testFrame = actorIval.getCurrentFrame()
self.notify.debug('actor ival is not stopped, testFrame=%f' % testFrame)
if testFrame:
curFrame = testFrame
break
if curFrame > -1:
duration = 0.25
if curFrame > self.ToonMaxRightFrame:
desiredFps = abs(self.JumpingFrame - curFrame) / duration
playRate = desiredFps / 24.0
retval = ActorInterval(base.localAvatar, 'swing', startFrame=curFrame, endFrame=self.JumpingFrame, playRate=playRate)
else:
numFrames = curFrame + 1
numFrames += SwingVine.SwingVine.MaxNumberOfFramesInSwingAnim - self.JumpingFrame + 1
desiredFps = numFrames / duration
playRate = desiredFps / 24.0
toonJump1 = ActorInterval(base.localAvatar, 'swing', startFrame=curFrame, endFrame=0, playRate=playRate)
toonJump2 = ActorInterval(base.localAvatar, 'swing', startFrame=SwingVine.SwingVine.MaxNumberOfFramesInSwingAnim - 1, endFrame=self.JumpingFrame, playRate=playRate)
retval = Sequence(toonJump1, toonJump2)
return retval
def detachLocalToonFromVine(self, vineIndex, facingRight):
vine = self.vines[vineIndex]
self.lastJumpVine = vineIndex
self.lastJumpTime = self.getCurrentGameTime()
self.curFrame = base.localAvatar.getCurrentFrame()
curInfo = vine.getAttachedToonInfo(base.localAvatar.doId)
if curInfo:
self.lastJumpPos = curInfo[1]
self.lastJumpT = curInfo[0]
else:
self.lastJumpPos = None
self.lastJumpT = 0
self.notify.warning('vine %d failed get tooninfo %d' % (vineIndex, base.localAvatar.doId))
self.setupJumpingTransitionIval(vineIndex)
self.vines[vineIndex].detachToon(base.localAvatar.doId)
return
def treasureEnter(self, entry):
self.notify.debug('---- treasure Enter ---- ')
self.notify.debug('%s' % entry)
name = entry.getIntoNodePath().getName()
parts = name.split('-')
if len(parts) < 3:
self.notify.debug('collided with %s, but returning' % name)
return
if not int(parts[1]) == self.doId:
self.notify.debug("collided with %s, but doId doesn't match" % name)
return
treasureNum = int(parts[2])
self.__treasureGrabbed(treasureNum)
def swingVineEnter(self, entry):
self.notify.debug('%s' % entry)
self.notify.debug('---- swingVine Enter ---- ')
name = entry.getIntoNodePath().getName()
parts = name.split('-')
if len(parts) < 3:
self.notify.debug('collided with %s, but returning' % name)
return
vineIndex = int(parts[1])
if vineIndex < 0 or vineIndex >= len(self.vines):
self.notify.warning('invalid vine index %d' % vineIndex)
return
if vineIndex == self.lastJumpVine:
if self.lastJumpPos:
diff = self.lastJumpPos - entry.getSurfacePoint(render)
if diff.length() < self.LocalPhysicsRadius:
return
if self.getCurrentGameTime() - self.lastJumpTime < VineGameGlobals.JumpTimeBuffer:
return
fallingInfo = self.toonInfo[self.localAvId][8]
if fallingInfo == self.FallingSpider or fallingInfo == self.FallingBat:
return
if abs(self.lastJumpVine - vineIndex) > 1:
return
vine = self.vines[vineIndex]
vineT = vine.calcTFromTubeHit(entry)
self.attachLocalToonToVine(vineIndex, vineT, False, playSfx=True)
self.setupAttachingToVineCamIval(vineIndex, self.lastJumpFacingRight)
def makeOtherToonJump(self, avId, posX, posZ, velX, velZ):
if avId not in self.otherToonPhysics:
an = ActorNode('other-physics%s' % avId)
anp = render.attachNewNode(an)
base.physicsMgr.attachPhysicalNode(an)
self.otherToonPhysics[avId] = (an, anp)
an, anp = self.otherToonPhysics[avId]
anp.setPos(posX, 0, posZ)
av = base.cr.doId2do.get(avId)
if av:
av.reparentTo(anp)
av.setPos(-self.toonOffsets[self.localAvId])
av.pose('swing', self.JumpingFrame)
self.notify.debug('pose set to swing jumping frame.')
if velX >= 0:
anp.setH(-90)
else:
anp.setH(90)
physObject = an.getPhysicsObject()
physObject.setVelocity(velX, 0, velZ)
def makeOtherToonFallFromMidair(self, avId, posX, posZ, velX, velZ):
if avId not in self.otherToonPhysics:
an = ActorNode('other-physics%s' % avId)
anp = render.attachNewNode(an)
base.physicsMgr.attachPhysicalNode(an)
self.otherToonPhysics[avId] = (an, anp)
an, anp = self.otherToonPhysics[avId]
anp.setPos(posX, 0, posZ)
av = base.cr.doId2do.get(avId)
if av:
av.reparentTo(anp)
av.setPos(-self.toonOffsets[self.localAvId])
if velX >= 0:
anp.setH(-90)
else:
anp.setH(90)
physObject = an.getPhysicsObject()
physObject.setVelocity(velX, 0, velZ)
def makeLocalToonJump(self, vineIndex, t, pos, normal):
self.jumpSound.play()
self.clearChangeFacingInterval()
self.clearAttachingToVineCamIval()
an = ActorNode('av-physics')
anp = render.attachNewNode(an)
anp.setPos(pos)
base.localAvatar.reparentTo(anp)
base.localAvatar.setPos(-self.toonOffsets[self.localAvId])
if normal.getX() >= 0:
self.lastJumpFacingRight = True
anp.setH(-90)
else:
anp.setH(90)
self.lastJumpFacingRight = False
base.physicsMgr.attachPhysicalNode(an)
physObject = an.getPhysicsObject()
velocity = normal * self.JumpSpeed
velocity *= t
self.notify.debug('jumping from vine with velocity of %s' % velocity)
physObject.setVelocity(velocity)
self.localPhysicsNP = anp
self.setupCollisions(anp)
if self.doingJumpTransition:
self.localToonJumpAnimIval.start()
else:
base.localAvatar.pose('swing', self.JumpingFrame)
self.b_setJumpingFromVine(self.localAvId, vineIndex, self.lastJumpFacingRight, pos[0], pos[2], velocity[0], velocity[2])
def makeLocalToonFallFromVine(self, fallingInfo):
self.clearAttachingToVineCamIval()
self.clearChangeFacingInterval()
vineIndex, vineInfo = self.getVineAndVineInfo(self.localAvId)
if vineIndex == -1:
self.notify.warning('we are not attached to a vine')
return
pos = vineInfo[1]
self.detachLocalToonFromVine(vineIndex, self.lastJumpFacingRight)
self.clearChangeFacingInterval()
an = ActorNode('av-physics')
anp = render.attachNewNode(an)
anp.setPos(vineInfo[1])
base.localAvatar.reparentTo(anp)
base.localAvatar.setPos(-self.toonOffsets[self.localAvId])
if self.lastJumpFacingRight:
anp.setH(-90)
else:
anp.setH(90)
base.physicsMgr.attachPhysicalNode(an)
physObject = an.getPhysicsObject()
velocity = Vec3(0, 0, -0.1)
physObject.setVelocity(velocity)
self.localPhysicsNP = anp
self.b_setFallingFromVine(self.localAvId, vineIndex, self.lastJumpFacingRight, pos[0], pos[2], velocity[0], velocity[2], fallingInfo)
def makeLocalToonFallFromMidair(self, fallingInfo):
vineIndex, vineInfo = self.getVineAndVineInfo(self.localAvId)
if not vineIndex == -1:
self.notify.warning(' makeLocalToonFallFromMidair we are still attached to a vine')
return
if not self.localPhysicsNP:
self.notify.warning('self.localPhysicsNP is invalid')
return
pos = self.localPhysicsNP.getPos()
an = self.localPhysicsNP.node()
physObject = an.getPhysicsObject()
velocity = Vec3(0, 0, -0.1)
physObject.setVelocity(velocity)
self.b_setFallingFromMidair(self.localAvId, self.lastJumpFacingRight, pos[0], pos[2], velocity[0], velocity[2], fallingInfo)
def changeLocalToonFacing(self, vineIndex, swingVineInfo, newFacingRight):
self.lastJumpFacingRight = newFacingRight
self.attachLocalToonToVine(vineIndex, swingVineInfo[0], focusCameraImmediately=False)
self.setupChangeFacingInterval(vineIndex, newFacingRight)
def upArrowKeyHandler(self):
self.sendNewVineTUpdateAsap = True
def downArrowKeyHandler(self):
self.sendNewVineTUpdateAsap = True
def rightArrowKeyHandler(self):
curInfo = None
for vineIndex in xrange(len(self.vines)):
curInfo = self.vines[vineIndex].getAttachedToonInfo(base.localAvatar.doId)
if curInfo:
break
if not curInfo:
return
if vineIndex == len(self.vines) - 1:
return
if not self.isInPlayState():
return
doJump = True
if self.ArrowToChangeFacing:
if not self.lastJumpFacingRight:
doJump = False
self.changeLocalToonFacing(vineIndex, curInfo, True)
if doJump:
self.detachLocalToonFromVine(vineIndex, 1)
normal = curInfo[2]
self.makeLocalToonJump(vineIndex, curInfo[0], curInfo[1], normal)
return
def leftArrowKeyHandler(self):
curInfo = None
for vineIndex in xrange(len(self.vines)):
curInfo = self.vines[vineIndex].getAttachedToonInfo(base.localAvatar.doId)
if curInfo:
break
curInfo = self.vines[vineIndex].getAttachedToonInfo(base.localAvatar.doId)
if not curInfo:
return
if vineIndex == 0:
return
if vineIndex == len(self.vines) - 1:
return
if not self.isInPlayState():
return
doJump = True
if self.ArrowToChangeFacing:
if self.lastJumpFacingRight:
doJump = False
self.changeLocalToonFacing(vineIndex, curInfo, False)
if doJump:
self.detachLocalToonFromVine(vineIndex, 0)
normal = curInfo[2]
normal *= -1
self.makeLocalToonJump(vineIndex, curInfo[0], curInfo[1], normal)
return
def b_setNewVine(self, avId, vineIndex, vineT, facingRight):
self.setNewVine(avId, vineIndex, vineT, facingRight)
self.d_setNewVine(avId, vineIndex, vineT, facingRight)
def d_setNewVine(self, avId, vineIndex, vineT, facingRight):
self.notify.debug('setNewVine avId=%d vineIndex=%s' % (avId, vineIndex))
self.sendUpdate('setNewVine', [avId,
vineIndex,
vineT,
facingRight])
def setNewVine(self, avId, vineIndex, vineT, facingRight):
self.updateToonInfo(avId, vineIndex=vineIndex, vineT=vineT, facingRight=facingRight, climbDir=0, fallingInfo=self.FallingNot)
def b_setNewVineT(self, avId, vineT, climbDir):
self.setNewVineT(avId, vineT, climbDir)
self.d_setNewVineT(avId, vineT, climbDir)
def d_setNewVineT(self, avId, vineT, climbDir):
sendIt = False
curTime = self.getCurrentGameTime()
if self.sendNewVineTUpdateAsap:
sendIt = True
elif curTime - self.lastNewVineTUpdate > 0.2:
sendIt = True
if sendIt:
self.sendUpdate('setNewVineT', [avId, vineT, climbDir])
self.sendNewVineTUpdateAsap = False
self.lastNewVineTUpdate = self.getCurrentGameTime()
def setNewVineT(self, avId, vineT, climbDir):
self.updateToonInfo(avId, vineT=vineT, climbDir=climbDir)
def b_setJumpingFromVine(self, avId, vineIndex, facingRight, posX, posZ, velX, velZ):
self.setJumpingFromVine(avId, vineIndex, facingRight, posX, posZ, velX, velZ)
self.d_setJumpingFromVine(avId, vineIndex, facingRight, posX, posZ, velX, velZ)
def d_setJumpingFromVine(self, avId, vineIndex, facingRight, posX, posZ, velX, velZ):
self.sendUpdate('setJumpingFromVine', [avId,
vineIndex,
facingRight,
posX,
posZ,
velX,
velZ])
def setJumpingFromVine(self, avId, vineIndex, facingRight, posX, posZ, velX, velZ):
self.updateToonInfo(avId, vineIndex=-1, facingRight=facingRight, posX=posX, posZ=posZ, velX=velX, velZ=velZ)
def b_setFallingFromVine(self, avId, vineIndex, facingRight, posX, posZ, velX, velZ, fallingInfo):
self.setFallingFromVine(avId, vineIndex, facingRight, posX, posZ, velX, velZ, fallingInfo)
self.d_setFallingFromVine(avId, vineIndex, facingRight, posX, posZ, velX, velZ, fallingInfo)
def d_setFallingFromVine(self, avId, vineIndex, facingRight, posX, posZ, velX, velZ, fallingInfo):
self.sendUpdate('setFallingFromVine', [avId,
vineIndex,
facingRight,
posX,
posZ,
velX,
velZ,
fallingInfo])
def setFallingFromVine(self, avId, vineIndex, facingRight, posX, posZ, velX, velZ, fallingInfo):
self.updateToonInfo(avId, vineIndex=-1, facingRight=facingRight, posX=posX, posZ=posZ, velX=velX, velZ=velZ, fallingInfo=fallingInfo)
def b_setFallingFromMidair(self, avId, facingRight, posX, posZ, velX, velZ, fallingInfo):
self.setFallingFromMidair(avId, facingRight, posX, posZ, velX, velZ, fallingInfo)
self.d_setFallingFromMidair(avId, facingRight, posX, posZ, velX, velZ, fallingInfo)
def d_setFallingFromMidair(self, avId, facingRight, posX, posZ, velX, velZ, fallingInfo):
self.sendUpdate('setFallingFromMidair', [avId,
facingRight,
posX,
posZ,
velX,
velZ,
fallingInfo])
def setFallingFromMidair(self, avId, facingRight, posX, posZ, velX, velZ, fallingInfo):
self.updateToonInfo(avId=avId, facingRight=facingRight, posX=posX, posZ=posZ, velX=velX, velZ=velZ, fallingInfo=fallingInfo)
def d_setFallingPos(self, avId, posX, posZ):
self.sendUpdate('setFallingPos', [avId, posX, posZ])
def setFallingPos(self, avId, posX, posZ):
self.updateToonInfo(avId, posX=posX, posZ=posZ)
def __treasureGrabbed(self, treasureNum):
self.treasures[treasureNum].showGrab()
self.grabSound.play()
self.sendUpdate('claimTreasure', [treasureNum])
def setTreasureGrabbed(self, avId, treasureNum):
if not self.hasLocalToon:
return
self.notify.debug('treasure %s grabbed by %s' % (treasureNum, avId))
if avId != self.localAvId:
self.treasures[treasureNum].showGrab()
i = self.avIdList.index(avId)
self.scores[i] += 1
self.scorePanels[i].setScore(self.scores[i])
def setScore(self, avId, score):
if not self.hasLocalToon:
return
i = self.avIdList.index(avId)
if hasattr(self, 'scorePanels'):
self.scores[i] += score
self.scorePanels[i].setScore(score)
def timerExpired(self):
self.notify.debug('game timer expired')
if not VineGameGlobals.EndlessGame:
if hasattr(self, 'gameFSM'):
self.gameFSM.request('showScores')
def allAtEndVine(self):
if not self.hasLocalToon:
return
self.notify.debug('all at end vine')
if not VineGameGlobals.EndlessGame:
self.gameFSM.request('showScores')
def clearChangeFacingInterval(self):
if self.changeFacingInterval:
self.changeFacingInterval.pause()
del self.changeFacingInterval
self.changeFacingInterval = None
return
def setupChangeFacingInterval(self, vineIndex, newFacingRight):
self.clearChangeFacingInterval()
self.changeFacingInterval = Sequence()
if not (vineIndex == 0 or vineIndex == VineGameGlobals.NumVines - 1):
destPos = self.getFocusCameraPos(vineIndex, newFacingRight)
self.changeFacingInterval.append(LerpPosInterval(base.camera, 0.5, destPos))
self.changeFacingInterval.append(Func(self.clearChangeFacingInterval))
self.changeFacingInterval.start()
def clearAttachingToVineCamIval(self):
if self.attachingToVineCamIval:
self.attachingToVineCamIval.pause()
del self.attachingToVineCamIval
self.attachingToVineCamIval = None
return
def setupAttachingToVineCamIval(self, vineIndex, facingRight):
self.clearAttachingToVineCamIval()
self.attachingToVineCamIval = Sequence()
destPos = self.getFocusCameraPos(vineIndex, facingRight)
self.attachingToVineCamIval.append(LerpPosInterval(base.camera, 0.5, destPos))
self.attachingToVineCamIval.append(Func(self.clearAttachingToVineCamIval))
self.attachingToVineCamIval.start()
def createRadar(self):
self.cCamera = render.attachNewNode('cCamera')
self.cCamNode = Camera('cCam')
self.cCamNode.setCameraMask(VineGameGlobals.RadarCameraBitmask)
self.cLens = PerspectiveLens()
xFov = 40
yFov = 2.5
self.cLens.setFov(xFov, yFov)
self.cLens.setNear(0.1)
self.cLens.setFar(1300.0)
self.cCamNode.setLens(self.cLens)
self.cCamNode.setScene(render)
self.cCam = self.cCamera.attachNewNode(self.cCamNode)
self.cCam.setPos(300, -850, 16.3)
endY = yFov / xFov
self.endZRadar = 0.09375
self.cDr = base.win.makeDisplayRegion(0, 1, 0, self.endZRadar)
self.cDr.setSort(1)
self.cDr.setClearDepthActive(1)
self.cDr.setClearColorActive(1)
self.cDr.setClearColor(Vec4(0.85, 0.95, 0.95, 1))
self.cDr.setCamera(self.cCam)
self.radarSeparator = DirectFrame(relief=None, image=DGG.getDefaultDialogGeom(), image_color=(0.2, 0.0, 0.8, 1), image_scale=(2.65, 1.0, 0.01), pos=(0, 0, -0.8125))
self.oldBaseCameraMask = base.camNode.getCameraMask()
base.camNode.setCameraMask(BitMask32.bit(0))
return
def destroyRadar(self):
base.win.removeDisplayRegion(self.cDr)
self.cCamera.removeNode()
del self.cCamera
del self.cCamNode
del self.cLens
del self.cCam
del self.cDr
self.radarSeparator.destroy()
del self.radarSeparator
base.camNode.setCameraMask(self.oldBaseCameraMask)
def updateRadar(self):
for avId in self.headFrames:
av = base.cr.doId2do.get(avId)
headFrameShown = False
if av:
avPos = av.getPos(render)
newPoint = self.mapRadarToAspect2d(render, avPos)
if newPoint:
headFrameShown = True
self.headFrames[avId].setPos(newPoint[0], newPoint[1], newPoint[2])
if headFrameShown:
self.headFrames[avId].show()
else:
self.headFrames[avId].hide()
def mapRadarToAspect2d(self, node, point):
if point[0] > 26:
pass
p3 = self.cCam.getRelativePoint(node, point)
p2 = Point2()
if not self.cLens.project(p3, p2):
return None
r2d = Point3(p2[0], 0, p2[1])
a2d = aspect2d.getRelativePoint(render2d, r2d)
zAspect2DRadar = self.endZRadar * 2.0 - 1
oldZ = a2d.getZ()
newZ = (oldZ + 1) / 2.0 * (zAspect2DRadar + 1)
newZ -= 1
a2d.setZ(newZ)
return a2d
def localToonHitSpider(self, colEntry):
self.notify.debug('toonHitSpider')
if self.toonInfo[self.localAvId][0] == -1:
fallingInfo = self.toonInfo[self.localAvId][8]
if not (fallingInfo == self.FallingBat or fallingInfo == self.FallingSpider):
self.spiderHitSound.play()
self.makeLocalToonFallFromMidair(self.FallingSpider)
else:
self.spiderHitSound.play()
self.makeLocalToonFallFromVine(self.FallingSpider)
def localToonHitBat(self, colEntry):
self.notify.debug('toonHitBat')
if self.toonInfo[self.localAvId][0] == VineGameGlobals.NumVines - 1:
return
if self.toonInfo[self.localAvId][0] == -1:
self.batHitMidairSound.play()
fallingInfo = self.toonInfo[self.localAvId][8]
if not (fallingInfo == self.FallingBat or fallingInfo == self.FallingSpider):
self.makeLocalToonFallFromMidair(self.FallingBat)
else:
self.batHitVineSound.play()
self.makeLocalToonFallFromVine(self.FallingBat)
def toonHitSomething(self, colEntry):
if not self.isInPlayState():
return
intoName = colEntry.getIntoNodePath().getName()
if 'spider' in intoName:
self.localToonHitSpider(colEntry)
elif 'bat' in intoName:
self.localToonHitBat(colEntry)
def setVineSections(self, vineSections):
self.vineSections = vineSections
def setupVineCourse(self):
vineIndex = 0
for section in self.vineSections:
for vineInfo in VineGameGlobals.CourseSections[section]:
length, baseAngle, vinePeriod, spiderPeriod = vineInfo
posX = vineIndex * VineGameGlobals.VineXIncrement
newVine = SwingVine.SwingVine(vineIndex, posX, 0, VineGameGlobals.VineHeight, length=length, baseAngle=baseAngle, period=vinePeriod, spiderPeriod=spiderPeriod)
self.vines.append(newVine)
vineIndex += 1
def loadBats(self):
self.bats = []
szId = self.getSafezoneId()
self.batInfo = VineGameGlobals.BatInfo[szId]
batIndex = 0
for batTuple in self.batInfo:
newBat = VineBat.VineBat(batIndex, self.batInfo[batIndex][0])
xPos = VineGameGlobals.VineXIncrement * VineGameGlobals.NumVines + 100
newBat.setX(xPos)
self.bats.append(newBat)
batIndex += 1
def createBatIvals(self):
self.batIvals = []
for batIndex in xrange(len(self.bats)):
newBatIval = self.createBatIval(batIndex)
self.batIvals.append(newBatIval)
def startBatIvals(self):
for batIval in self.batIvals:
batIval.start()
def destroyBatIvals(self):
for batIval in self.batIvals:
batIval.finish()
self.batIvals = []
def createBatIval(self, batIndex):
timeToTraverseField = self.batInfo[batIndex][0]
initialDelay = self.batInfo[batIndex][1]
startMultiplier = 1
if len(self.batInfo[batIndex]) >= 3:
startMultiplier = 0.25
batIval = Sequence()
batIval.append(Wait(initialDelay))
batIval.append(Func(self.bats[batIndex].startFlying))
startX = VineGameGlobals.VineXIncrement * VineGameGlobals.NumVines
endX = -VineGameGlobals.VineXIncrement
firstInterval = True
while batIval.getDuration() < VineGameGlobals.GameDuration:
batHeight = self.randomNumGen.randrange(VineGameGlobals.BatMinHeight, VineGameGlobals.BatMaxHeight)
batIval.append(Func(self.bats[batIndex].startLap))
if firstInterval:
newIval = LerpPosInterval(self.bats[batIndex], duration=timeToTraverseField * startMultiplier, pos=Point3(endX, 0, batHeight), startPos=Point3(startX * startMultiplier, 0, batHeight))
else:
newIval = LerpPosInterval(self.bats[batIndex], duration=timeToTraverseField, pos=Point3(endX, 0, batHeight), startPos=Point3(startX, 0, batHeight))
batIval.append(newIval)
firstInterval = False
batIval.append(Func(self.bats[batIndex].stopFlying))
return batIval
def isInPlayState(self):
if not self.gameFSM.getCurrentState():
return False
if not self.gameFSM.getCurrentState().getName() == 'play':
return False
return True
def getIntroTrack(self):
retval = Sequence()
toonTakeoffs = Parallel()
didCameraMove = False
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
if avId != self.localAvId:
continue
oneSeq = Sequence()
oneSeqAndHowl = Parallel()
av = base.cr.doId2do.get(avId)
if av:
toonOffset = self.calcToonOffset(av)
platformPos = self.startPlatform.getPos()
endPos = self.vines[0].getPos()
endPos.setZ(endPos.getZ() - toonOffset.getZ() - VineGameGlobals.VineStartingT * self.vines[0].cableLength)
xPos = platformPos[0] - 0.5
takeOffPos = Point3(xPos, platformPos[1], platformPos[2])
leftPos = Point3(xPos - 27, platformPos[1], platformPos[2])
self.notify.debug('leftPos = %s platformPos=%s' % (leftPos, platformPos))
startRunningPos = Point3(takeOffPos)
startRunningPos.setX(startRunningPos.getX() - 7)
oneSeq.append(Func(av.dropShadow.show))
oneSeq.append(Func(av.setH, -90))
oneSeq.append(Func(av.setPos, takeOffPos[0], takeOffPos[1], takeOffPos[2]))
exclamationSfx = av.getDialogueSfx('exclamation', 0)
oneSeq.append(Parallel(ActorInterval(av, 'confused', duration=3)))
questionSfx = av.getDialogueSfx('question', 0)
oneSeq.append(Parallel(ActorInterval(av, 'think', duration=3.0), SoundInterval(questionSfx, duration=3)))
oneSeq.append(Func(av.setH, 90))
oneSeq.append(Func(av.setPlayRate, 1, 'walk'))
oneSeq.append(Func(av.loop, 'walk'))
oneSeq.append(Parallel(LerpPosInterval(av, pos=leftPos, duration=5.25), SoundInterval(av.soundWalk, loop=1, duration=5.25)))
oneSeq.append(Func(av.setH, -90))
oneSeq.append(Func(av.loop, 'run'))
oneSeq.append(Parallel(LerpPosInterval(av, pos=takeOffPos, duration=2.5), SoundInterval(av.soundRun, loop=1, duration=2.5)))
oneSeq.append(Func(av.dropShadow.hide))
howlTime = oneSeq.getDuration()
oneSeq.append(Parallel(LerpPosInterval(av, pos=endPos, duration=0.5), Func(av.pose, 'swing', self.JumpingFrame)))
attachingToVineSeq = Sequence(ActorInterval(av, 'swing', startFrame=self.JumpingFrame, endFrame=143, playRate=2.0), ActorInterval(av, 'swing', startFrame=0, endFrame=86, playRate=2.0))
attachingToVine = Parallel(attachingToVineSeq, SoundInterval(self.catchSound))
if didCameraMove:
oneSeq.append(attachingToVine)
else:
attachAndMoveCam = Parallel(attachingToVine, LerpPosInterval(base.camera, pos=self.getFocusCameraPos(0, True), duration=2))
oneSeq.append(attachAndMoveCam)
oneSeq.append(Func(av.setPos, 0, 0, 0))
oneSeq.append(Func(av.setH, 0))
oneSeq.append(Func(self.vines[0].attachToon, avId, VineGameGlobals.VineStartingT, self.lastJumpFacingRight, setupAnim=False))
oneSeq.append(Func(self.vines[0].updateAttachedToons))
howlSfx = av.getDialogueSfx('special', 0)
howlSeq = Sequence(Wait(howlTime), SoundInterval(howlSfx))
exclamationSeq = Sequence(Wait(0.5), SoundInterval(exclamationSfx))
oneSeqAndHowl = Parallel(oneSeq, howlSeq, exclamationSeq)
toonTakeoffs.append(oneSeqAndHowl)
retval.append(toonTakeoffs)
return retval
def doEndingTrackTask(self, avId):
taskName = 'VineGameEnding-%s' % avId
if avId not in self.endingTracks:
taskMgr.doMethodLater(0.5, self.setupEndingTrack, taskName, extraArgs=(avId,))
self.endingTrackTaskNames.append(taskName)
def debugCameraPos(self):
self.notify.debug('cameraPos = %s' % base.camera.getPos())
def setupEndingTrack(self, avId):
if avId in self.endingTracks:
self.notify.warning('setupEndingTrack duplicate call avId=%d' % avId)
return
if len(self.vines) == 0:
return
endVine = VineGameGlobals.NumVines - 1
platformPos = self.endPlatform.getPos()
avIndex = self.avIdList.index(avId)
landingPos = Point3(platformPos)
landingPos.setX(landingPos.getX() + avIndex * 2)
endingTrack = Sequence()
av = base.cr.doId2do.get(avId)
avPos = av.getPos(render)
cameraPos = base.camera.getPos()
self.notify.debug('avPos=%s cameraPos=%s' % (avPos, base.camera.getPos()))
if av:
midX = landingPos[0]
midZ = platformPos[2] + 6
jumpingTransition = self.createJumpingTransitionIval(endVine)
endingTrack.append(Func(self.vines[endVine].detachToon, avId))
endingTrack.append(Func(av.wrtReparentTo, render))
endingTrack.append(Func(self.debugCameraPos))
endingTrack.append(Func(av.loop, 'jump-idle'))
landingIval = Parallel(ProjectileInterval(av, startPos=av.getPos(render), endZ=landingPos[2], wayPoint=Point3(midX, 0, midZ), timeToWayPoint=1))
endingTrack.append(landingIval)
endingTrack.append(Func(av.dropShadow.show))
endingTrack.append(Func(av.play, 'jump-land'))
endingTrack.append(Func(self.winSound.play))
endingTrack.append(Func(av.loop, 'victory'))
self.endingTracks[avId] = endingTrack
endingTrack.start()
return Task.done
def cleanupEndingTracks(self):
for taskName in self.endingTrackTaskNames:
taskMgr.remove(taskName)
for endingTrack in self.endingTracks.values():
endingTrack.finish
del endingTrack
self.endingTracks = {}
Reference in a new issue Copy permalink