def _initIntervals(self):
self._healthIval = LerpFunctionInterval(self.healthBar.setSz, fromData=0.0, toData=1.0, duration=2.0)
self.baseSpinDuration = 2.0
self._spinIval = LerpFunctionInterval(self.propellerMain.setR, fromData=0.0, toData=-360.0, duration=self.baseSpinDuration)
def showToonHitBySuit(self, avId, timestamp):
toon = self.getAvatar(avId)
if toon == None:
return
rng = self.toonRNGs[self.avIdList.index(avId)]
curPos = toon.getPos(render)
oldTrack = self.toonHitTracks[avId]
if oldTrack.isPlaying():
oldTrack.finish()
toon.setPos(curPos)
toon.setZ(self.TOON_Z)
parentNode = render.attachNewNode('mazeFlyToonParent-' + `avId`)
parentNode.setPos(toon.getPos())
toon.reparentTo(parentNode)
toon.setPos(0, 0, 0)
startPos = parentNode.getPos()
dropShadow = toon.dropShadow.copyTo(parentNode)
dropShadow.setScale(toon.dropShadow.getScale(render))
trajectory = Trajectory.Trajectory(0, Point3(0, 0, 0), Point3(0, 0, 50), gravMult=1.0)
oldFlyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
trajectory = Trajectory.Trajectory(0, Point3(0, 0, 0), Point3(0, 0, 40), gravMult=1.0)
flyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
avIndex = self.avIdList.index(avId)
endPos = CTGG.ToonStartingPositions[avIndex]
def flyFunc(t, trajectory, startPos = startPos, endPos = endPos, dur = flyDur, moveNode = parentNode, flyNode = toon):
u = t / dur
moveNode.setX(startPos[0] + u * (endPos[0] - startPos[0]))
moveNode.setY(startPos[1] + u * (endPos[1] - startPos[1]))
flyNode.setPos(trajectory.getPos(t))
flyTrack = Sequence(LerpFunctionInterval(flyFunc, fromData=0.0, toData=flyDur, duration=flyDur, extraArgs=[trajectory]), name=toon.uniqueName('hitBySuit-fly'))
geomNode = toon.getGeomNode()
startHpr = geomNode.getHpr()
destHpr = Point3(startHpr)
hRot = rng.randrange(1, 8)
if rng.choice([0, 1]):
hRot = -hRot
destHpr.setX(destHpr[0] + hRot * 360)
spinHTrack = Sequence(LerpHprInterval(geomNode, flyDur, destHpr, startHpr=startHpr), Func(geomNode.setHpr, startHpr), name=toon.uniqueName('hitBySuit-spinH'))
parent = geomNode.getParent()
rotNode = parent.attachNewNode('rotNode')
geomNode.reparentTo(rotNode)
rotNode.setZ(toon.getHeight() / 2.0)
oldGeomNodeZ = geomNode.getZ()
geomNode.setZ(-toon.getHeight() / 2.0)
startHpr = rotNode.getHpr()
destHpr = Point3(startHpr)
pRot = rng.randrange(1, 3)
if rng.choice([0, 1]):
pRot = -pRot
destHpr.setY(destHpr[1] + pRot * 360)
spinPTrack = Sequence(LerpHprInterval(rotNode, flyDur, destHpr, startHpr=startHpr), Func(rotNode.setHpr, startHpr), name=toon.uniqueName('hitBySuit-spinP'))
i = self.avIdList.index(avId)
soundTrack = Sequence(Func(base.playSfx, self.sndTable['hitBySuit'][i]), Wait(flyDur * (2.0 / 3.0)), SoundInterval(self.sndTable['falling'][i], duration=flyDur * (1.0 / 3.0)), name=toon.uniqueName('hitBySuit-soundTrack'))
def preFunc(self = self, avId = avId, toon = toon, dropShadow = dropShadow):
forwardSpeed = toon.forwardSpeed
rotateSpeed = toon.rotateSpeed
if avId == self.localAvId:
self.stopGameWalk()
else:
toon.stopSmooth()
if forwardSpeed or rotateSpeed:
toon.setSpeed(forwardSpeed, rotateSpeed)
toon.dropShadow.hide()
def postFunc(self = self, avId = avId, oldGeomNodeZ = oldGeomNodeZ, dropShadow = dropShadow, parentNode = parentNode):
if avId == self.localAvId:
base.localAvatar.setPos(endPos)
if hasattr(self, 'gameWalk'):
toon = base.localAvatar
toon.setSpeed(0, 0)
self.startGameWalk()
dropShadow.removeNode()
del dropShadow
toon = self.getAvatar(avId)
if toon:
toon.dropShadow.show()
geomNode = toon.getGeomNode()
rotNode = geomNode.getParent()
baseNode = rotNode.getParent()
geomNode.reparentTo(baseNode)
rotNode.removeNode()
del rotNode
geomNode.setZ(oldGeomNodeZ)
if toon:
toon.reparentTo(render)
toon.setPos(endPos)
parentNode.removeNode()
del parentNode
if avId != self.localAvId:
if toon:
toon.startSmooth()
preFunc()
slipBack = Parallel(Sequence(ActorInterval(toon, 'slip-backward', endFrame=24), ActorInterval(toon, 'slip-backward', startFrame=24)))
if toon.doId == self.localAvId:
slipBack.append(SoundInterval(self.sndOof))
hitTrack = Sequence(Parallel(flyTrack, spinHTrack, spinPTrack, soundTrack), slipBack, Func(postFunc), name=toon.uniqueName('hitBySuit'))
self.notify.debug('hitTrack duration = %s' % hitTrack.getDuration())
self.toonHitTracks[avId] = hitTrack
hitTrack.start(globalClockDelta.localElapsedTime(timestamp))
return
def setEveryoneDone(self):
if not self.hasLocalToon: return
if self.gameFSM.getCurrentState().getName() != 'play':
self.notify.warning('ignoring setEveryoneDone msg')
return
self.notify.debug('setEveryoneDone')
def endGame(task, self=self):
if not PairingGameGlobals.EndlessGame:
self.gameOver()
return Task.done
# hide the timer
self.timer.hide()
# hide the bonus
self.bonusGlow.hide()
# if it was a perfect game, let the players know
if len(self.inactiveList) == len(self.cards):
self.notify.debug("perfect game!")
perfectTextSubnode = hidden.attachNewNode(
self.__genText(TTLocalizer.PairingGamePerfect))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
# offset the subnode so that the text is centered on both axes
# we need the parent node so that the text will scale correctly
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3])/2.
perfectTextSubnode.setPos(0,0,offsetY)
perfectText.setColor(1,.1,.1,1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1,1,1,t)
def destroyText(text=perfectText):
text.removeNode()
textTrack = Sequence(
Func(perfectText.reparentTo, aspect2d),
Parallel(LerpScaleInterval(perfectText, duration=.5,
scale=.3, startScale=0.),
LerpFunctionInterval(fadeFunc,
fromData=0., toData=1.,
duration=.5,)
),
Wait(2.),
Parallel(LerpScaleInterval(perfectText, duration=.5,
scale=1.),
LerpFunctionInterval(fadeFunc,
fromData=1., toData=0.,
duration=.5,
blendType="easeIn"),
),
Func(destroyText),
WaitInterval(.5),
Func(endGame, None),
)
soundTrack = SoundInterval(self.sndPerfect)
self.perfectIval = Parallel(textTrack,
soundTrack)
self.perfectIval.start()
else:
taskMgr.doMethodLater(1, endGame, self.EndGameTaskName)
def __showToonHitBySuit(self, avId, timestamp):
toon = self.getAvatar(avId)
if toon == None:
return
rng = self.toonRNGs[self.avIdList.index(avId)]
curPos = toon.getPos(render)
oldTrack = self.toonHitTracks[avId]
if oldTrack.isPlaying():
oldTrack.finish()
toon.setPos(curPos)
toon.setZ(self.TOON_Z)
parentNode = render.attachNewNode('mazeFlyToonParent-' + ` avId `)
parentNode.setPos(toon.getPos())
toon.reparentTo(parentNode)
toon.setPos(0, 0, 0)
startPos = parentNode.getPos()
dropShadow = toon.dropShadow.copyTo(parentNode)
dropShadow.setScale(toon.dropShadow.getScale(render))
trajectory = Trajectory.Trajectory(0,
Point3(0, 0, 0),
Point3(0, 0, 50),
gravMult=1.0)
flyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
while 1:
endTile = [
rng.randint(2, self.maze.width - 1),
rng.randint(2, self.maze.height - 1)
]
if self.maze.isWalkable(endTile[0], endTile[1]):
break
endWorldCoords = self.maze.tile2world(endTile[0], endTile[1])
endPos = Point3(endWorldCoords[0], endWorldCoords[1], startPos[2])
def flyFunc(t,
trajectory,
startPos=startPos,
endPos=endPos,
dur=flyDur,
moveNode=parentNode,
flyNode=toon):
u = t / dur
moveNode.setX(startPos[0] + u * (endPos[0] - startPos[0]))
moveNode.setY(startPos[1] + u * (endPos[1] - startPos[1]))
flyNode.setPos(trajectory.getPos(t))
flyTrack = Sequence(LerpFunctionInterval(flyFunc,
fromData=0.0,
toData=flyDur,
duration=flyDur,
extraArgs=[trajectory]),
name=toon.uniqueName('hitBySuit-fly'))
if avId != self.localAvId:
cameraTrack = Sequence()
else:
self.camParent.reparentTo(parentNode)
startCamPos = camera.getPos()
destCamPos = camera.getPos()
zenith = trajectory.getPos(flyDur / 2.0)[2]
destCamPos.setZ(zenith * 1.3)
destCamPos.setY(destCamPos[1] * 0.3)
def camTask(task,
zenith=zenith,
flyNode=toon,
startCamPos=startCamPos,
camOffset=destCamPos - startCamPos):
u = flyNode.getZ() / zenith
camera.setPos(startCamPos + camOffset * u)
camera.lookAt(toon)
return Task.cont
camTaskName = 'mazeToonFlyCam-' + ` avId `
taskMgr.add(camTask, camTaskName, priority=20)
def cleanupCamTask(self=self,
toon=toon,
camTaskName=camTaskName,
startCamPos=startCamPos):
taskMgr.remove(camTaskName)
self.camParent.reparentTo(toon)
camera.setPos(startCamPos)
camera.lookAt(toon)
cameraTrack = Sequence(Wait(flyDur),
Func(cleanupCamTask),
name='hitBySuit-cameraLerp')
geomNode = toon.getGeomNode()
startHpr = geomNode.getHpr()
destHpr = Point3(startHpr)
hRot = rng.randrange(1, 8)
if rng.choice([0, 1]):
hRot = -hRot
destHpr.setX(destHpr[0] + hRot * 360)
spinHTrack = Sequence(LerpHprInterval(geomNode,
flyDur,
destHpr,
startHpr=startHpr),
Func(geomNode.setHpr, startHpr),
name=toon.uniqueName('hitBySuit-spinH'))
parent = geomNode.getParent()
rotNode = parent.attachNewNode('rotNode')
geomNode.reparentTo(rotNode)
rotNode.setZ(toon.getHeight() / 2.0)
oldGeomNodeZ = geomNode.getZ()
geomNode.setZ(-toon.getHeight() / 2.0)
startHpr = rotNode.getHpr()
destHpr = Point3(startHpr)
pRot = rng.randrange(1, 3)
if rng.choice([0, 1]):
pRot = -pRot
destHpr.setY(destHpr[1] + pRot * 360)
spinPTrack = Sequence(LerpHprInterval(rotNode,
flyDur,
destHpr,
startHpr=startHpr),
Func(rotNode.setHpr, startHpr),
name=toon.uniqueName('hitBySuit-spinP'))
i = self.avIdList.index(avId)
soundTrack = Sequence(Func(base.playSfx,
self.sndTable['hitBySuit'][i]),
Wait(flyDur * (2.0 / 3.0)),
SoundInterval(self.sndTable['falling'][i],
duration=flyDur * (1.0 / 3.0)),
name=toon.uniqueName('hitBySuit-soundTrack'))
def preFunc(self=self, avId=avId, toon=toon, dropShadow=dropShadow):
forwardSpeed = toon.forwardSpeed
rotateSpeed = toon.rotateSpeed
if avId == self.localAvId:
self.orthoWalk.stop()
else:
toon.stopSmooth()
if forwardSpeed or rotateSpeed:
toon.setSpeed(forwardSpeed, rotateSpeed)
toon.dropShadow.hide()
def postFunc(self=self,
avId=avId,
oldGeomNodeZ=oldGeomNodeZ,
dropShadow=dropShadow,
parentNode=parentNode):
if avId == self.localAvId:
base.localAvatar.setPos(endPos)
if hasattr(self, 'orthoWalk'):
if self.gameFSM.getCurrentState().getName() == 'play':
self.orthoWalk.start()
dropShadow.removeNode()
del dropShadow
toon.dropShadow.show()
geomNode = toon.getGeomNode()
rotNode = geomNode.getParent()
baseNode = rotNode.getParent()
geomNode.reparentTo(baseNode)
rotNode.removeNode()
del rotNode
geomNode.setZ(oldGeomNodeZ)
toon.reparentTo(render)
toon.setPos(endPos)
parentNode.removeNode()
del parentNode
if avId != self.localAvId:
toon.startSmooth()
preFunc()
hitTrack = Sequence(Parallel(flyTrack, cameraTrack, spinHTrack,
spinPTrack, soundTrack),
Func(postFunc),
name=toon.uniqueName('hitBySuit'))
self.toonHitTracks[avId] = hitTrack
hitTrack.start(globalClockDelta.localElapsedTime(timestamp))
def enterScoring(self):
sortedByDistance = []
for avId in self.avIdList:
np = self.getTireNp(avId)
pos = np.getPos()
pos.setZ(0)
sortedByDistance.append((avId, pos.length()))
def compareDistance(x, y):
if x[1] - y[1] > 0:
return 1
if x[1] - y[1] < 0:
return -1
return 0
sortedByDistance.sort(cmp=compareDistance)
self.scoreMovie = Sequence()
curScale = 0.01
curTime = 0
self.scoreCircle.setScale(0.01)
self.scoreCircle.show()
self.notify.debug('newScores = %s' % self.newScores)
circleStartTime = 0
for index in xrange(len(sortedByDistance)):
distance = sortedByDistance[index][1]
avId = sortedByDistance[index][0]
scorePanelIndex = self.avIdList.index(avId)
time = (distance - curScale) / IceGameGlobals.ExpandFeetPerSec
if time < 0:
time = 0.01
scaleXY = distance + IceGameGlobals.TireRadius
self.notify.debug('circleStartTime = %s' % circleStartTime)
self.scoreMovie.append(
Parallel(
LerpScaleInterval(self.scoreCircle, time,
Point3(scaleXY, scaleXY, 1.0)),
SoundInterval(self.scoreCircleSound,
duration=time,
startTime=circleStartTime)))
circleStartTime += time
startScore = self.scorePanels[scorePanelIndex].getScore()
destScore = self.newScores[scorePanelIndex]
self.notify.debug('for avId %d, startScore=%d, newScores=%d' %
(avId, startScore, destScore))
def increaseScores(t,
scorePanelIndex=scorePanelIndex,
startScore=startScore,
destScore=destScore):
oldScore = self.scorePanels[scorePanelIndex].getScore()
diff = destScore - startScore
newScore = int(startScore + diff * t)
if newScore > oldScore:
base.playSfx(self.countSound)
self.scorePanels[scorePanelIndex].setScore(newScore)
self.scores[scorePanelIndex] = newScore
duration = (destScore -
startScore) * IceGameGlobals.ScoreCountUpRate
tireNp = self.tireDict[avId]['tireNodePath']
self.scoreMovie.append(
Parallel(
LerpFunctionInterval(increaseScores, duration),
Sequence(
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)))))
curScale += distance
self.scoreMovie.append(
Func(self.sendUpdate, 'reportScoringMovieDone', []))
self.scoreMovie.start()
def showResults(self):
if not self.gameIsEnding:
self.gameIsEnding = True
for barrel in self.barrels:
barrel.wrtReparentTo(render)
for key in self.cogInfo:
thief = self.cogInfo[key]['suit']
thief.suit.setPos(100, 0, 0)
thief.suit.hide()
self.__killRewardCountdown()
self.stopGameWalk()
numBarrelsSaved = len(self.barrels) - len(self.stolenBarrels)
resultStr = ''
if numBarrelsSaved == len(self.barrels):
resultStr = TTLocalizer.CogThiefPerfect
elif numBarrelsSaved > 1:
resultStr = TTLocalizer.CogThiefBarrelsSaved % {
'num': numBarrelsSaved
}
elif numBarrelsSaved == 1:
resultStr = TTLocalizer.CogThiefBarrelSaved % {
'num': numBarrelsSaved
}
else:
resultStr = TTLocalizer.CogThiefNoBarrelsSaved
perfectTextSubnode = hidden.attachNewNode(
self.__genText(resultStr))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text=perfectText):
text.removeNode()
def safeGameOver(self=self):
if not self.frameworkFSM.isInternalStateInFlux():
self.gameOver()
textTrack = Sequence(
Func(perfectText.reparentTo, aspect2d),
Parallel(
LerpScaleInterval(perfectText,
duration=0.5,
scale=0.3,
startScale=0.0),
LerpFunctionInterval(fadeFunc,
fromData=0.0,
toData=1.0,
duration=0.5)), Wait(2.0),
Parallel(
LerpScaleInterval(perfectText, duration=0.5, scale=1.0),
LerpFunctionInterval(fadeFunc,
fromData=1.0,
toData=0.0,
duration=0.5,
blendType='easeIn')),
Func(destroyText), WaitInterval(0.5), Func(safeGameOver))
if numBarrelsSaved == len(self.barrels):
soundTrack = SoundInterval(self.sndPerfect)
else:
soundTrack = Sequence()
self.resultIval = Parallel(textTrack, soundTrack)
self.resultIval.start()
def initIntervals(self):
self.deathInterval = Sequence(
Func(self.inputMgr.disable),
Parallel(
LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)),
LerpFunctionInterval(self.toon.setScale,
fromData=1.0,
toData=0.0,
duration=1.0)),
Func(self.resetToon),
Wait(
0.5
), # Added this because with no pause here the FreeFly prop sound was attached to the old toon pos
Func(self.request, "FreeFly"),
name="%s.deathInterval" % (self.__class__.__name__))
self.refuelInterval = Sequence(
Func(self.guiMgr.setRefuelLerpFromData),
Func(self.guiMgr.messageLabel.unstash),
Parallel(
self.guiMgr.refuelLerp,
Sequence(
Func(self.guiMgr.setMessageLabelText, "Refueling"),
Wait(0.5),
Func(self.guiMgr.setMessageLabelText, "Refueling."),
Wait(0.5),
Func(self.guiMgr.setMessageLabelText, "Refueling.."),
Wait(0.5),
Func(self.guiMgr.setMessageLabelText, "Refueling..."),
Wait(0.5),
),
),
Func(self.resetFuel),
Func(self.guiMgr.messageLabel.stash),
Func(self.request, "FreeFly"),
name="%s.refuelInterval" % (self.__class__.__name__))
self.waitingForWinInterval = Sequence(
Func(self.guiMgr.setMessageLabelText, "Waiting for other players"),
Wait(1.5),
Func(self.guiMgr.setMessageLabelText,
"Waiting for other players."),
Wait(1.5),
Func(self.guiMgr.setMessageLabelText,
"Waiting for other players.."),
Wait(1.5),
Func(self.guiMgr.setMessageLabelText,
"Waiting for other players..."),
Wait(1.5),
name="%s.waitingForWinInterval" % (self.__class__.__name__))
self.winInterval = Sequence(Func(self.guiMgr.setMessageLabelText, ""),
Wait(1.0),
Func(self.guiMgr.winLabel.unstash),
Wait(2.0),
Func(self.guiMgr.winLabel.stash),
Wait(0.5),
Func(messenger.send, "escape"),
name="%s.waitingForWinInterval" %
(self.__class__.__name__))
self.slowPropTrack = Parallel(
ActorInterval(self.props['1000'],
'propeller',
startFrame=8,
endFrame=23,
playRate=1.0),
ActorInterval(self.props['500'],
'propeller',
startFrame=8,
endFrame=23,
playRate=1.0),
ActorInterval(self.props['250'],
'propeller',
startFrame=8,
endFrame=23,
playRate=1.0),
)
self.fastPropTrack = Parallel(
ActorInterval(self.props['1000'],
'propeller',
startFrame=8,
endFrame=23,
playRate=2.0),
ActorInterval(self.props['500'],
'propeller',
startFrame=8,
endFrame=23,
playRate=2.0),
ActorInterval(self.props['250'],
'propeller',
startFrame=8,
endFrame=23,
playRate=2.0),
)
def startConclusion(self):
DistributedPartyCatchActivity.notify.debug('startConclusion')
for avId in self.toonIds:
if self.toonSDs.has_key(avId):
toonSD = self.toonSDs[avId]
toonSD.fsm.request('notPlaying')
self.destroyCatchCollisions()
if base.localAvatar.doId not in self.toonIds:
return
else:
self.localToonExiting()
if self.fruitsCaught >= self.numFruits:
finishText = TTLocalizer.PartyCatchActivityFinishPerfect
else:
finishText = TTLocalizer.PartyCatchActivityFinish
perfectTextSubnode = hidden.attachNewNode(self.__genText(finishText))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text=perfectText):
text.removeNode()
textTrack = Sequence(Func(perfectText.reparentTo, aspect2d), Parallel(LerpScaleInterval(perfectText, duration=0.5, scale=0.3, startScale=0.0), LerpFunctionInterval(fadeFunc, fromData=0.0, toData=1.0, duration=0.5)), Wait(2.0), Parallel(LerpScaleInterval(perfectText, duration=0.5, scale=1.0), LerpFunctionInterval(fadeFunc, fromData=1.0, toData=0.0, duration=0.5, blendType='easeIn')), Func(destroyText), WaitInterval(0.5))
soundTrack = SoundInterval(self.sndPerfect)
self.finishIval = Parallel(textTrack, soundTrack)
self.finishIval.start()
def getDropIval(self, x, y, dropObjName, generation, num):
objType = PartyGlobals.Name2DropObjectType[dropObjName]
id = (
generation, num)
dropNode = hidden.attachNewNode('catchDropNode%s' % (id,))
dropNode.setPos(x, y, 0)
shadow = self.dropShadow.copyTo(dropNode)
shadow.setZ(PartyGlobals.CatchDropShadowHeight)
shadow.setColor(1, 1, 1, 1)
object = self.getObjModel(dropObjName)
object.reparentTo(hidden)
if dropObjName in ['watermelon', 'anvil']:
objH = object.getH()
absDelta = {'watermelon': 12,'anvil': 15}[dropObjName]
delta = (self.randomNumGen.random() * 2.0 - 1.0) * absDelta
newH = objH + delta
else:
newH = self.randomNumGen.random() * 360.0
object.setH(newH)
sphereName = 'FallObj%s' % (id,)
radius = self.ObjRadius
if objType.good:
radius *= lerp(1.0, 1.3, 0.5)
collSphere = CollisionSphere(0, 0, 0, radius)
collSphere.setTangible(0)
collNode = CollisionNode(sphereName)
collNode.setCollideMask(PartyGlobals.CatchActivityBitmask)
collNode.addSolid(collSphere)
collNodePath = object.attachNewNode(collNode)
collNodePath.hide()
if self.ShowObjSpheres:
collNodePath.show()
catchEventName = 'ltCatch' + sphereName
def eatCollEntry(forward, collEntry):
forward()
self.accept(catchEventName, Functor(eatCollEntry, Functor(self.__handleCatch, id[0], id[1])))
def cleanup(self=self, dropNode=dropNode, id=id, event=catchEventName):
self.ignore(event)
dropNode.removeNode()
duration = objType.fallDuration
onscreenDuration = objType.onscreenDuration
targetShadowScale = 0.3
if self.trickShadows:
intermedScale = targetShadowScale * (self.OffscreenTime / self.BaselineDropDuration)
shadowScaleIval = Sequence(LerpScaleInterval(shadow, self.OffscreenTime, intermedScale, startScale=0))
shadowScaleIval.append(LerpScaleInterval(shadow, duration - self.OffscreenTime, targetShadowScale, startScale=intermedScale))
else:
shadowScaleIval = LerpScaleInterval(shadow, duration, targetShadowScale, startScale=0)
targetShadowAlpha = 0.4
shadowAlphaIval = LerpColorScaleInterval(shadow, self.OffscreenTime, Point4(1, 1, 1, targetShadowAlpha), startColorScale=Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
if self.useGravity:
def setObjPos(t, objType=objType, object=object):
z = objType.trajectory.calcZ(t)
object.setZ(z)
setObjPos(0)
dropIval = LerpFunctionInterval(setObjPos, fromData=0, toData=onscreenDuration, duration=onscreenDuration)
else:
startPos = Point3(0, 0, self.MinOffscreenHeight)
object.setPos(startPos)
dropIval = LerpPosInterval(object, onscreenDuration, Point3(0, 0, 0), startPos=startPos, blendType='easeIn')
ival = Sequence(Func(Functor(dropNode.reparentTo, self.root)), Parallel(Sequence(WaitInterval(self.OffscreenTime), Func(Functor(object.reparentTo, dropNode)), dropIval), shadowIval), Func(cleanup), name='drop%s' % (id,))
if objType == PartyGlobals.Name2DropObjectType['anvil']:
ival.append(Func(self.playAnvil))
return ival
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 setEveryoneDone(self):
if not self.hasLocalToon:
return
if self.gameFSM.getCurrentState().getName() != 'play':
self.notify.warning('ignoring setEveryoneDone msg')
return
self.notify.debug('setEveryoneDone')
def endGame(task, self = self):
if not PairingGameGlobals.EndlessGame:
self.gameOver()
return Task.done
self.timer.hide()
self.bonusGlow.hide()
if len(self.inactiveList) == len(self.cards):
self.notify.debug('perfect game!')
perfectTextSubnode = hidden.attachNewNode(self.__genText(TTLocalizer.PairingGamePerfect))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text = perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text = perfectText):
text.removeNode()
textTrack = Sequence(Func(perfectText.reparentTo, aspect2d), Parallel(LerpScaleInterval(perfectText, duration=0.5, scale=0.3, startScale=0.0), LerpFunctionInterval(fadeFunc, fromData=0.0, toData=1.0, duration=0.5)), Wait(2.0), Parallel(LerpScaleInterval(perfectText, duration=0.5, scale=1.0), LerpFunctionInterval(fadeFunc, fromData=1.0, toData=0.0, duration=0.5, blendType='easeIn')), Func(destroyText), WaitInterval(0.5), Func(endGame, None))
soundTrack = SoundInterval(self.sndPerfect)
self.perfectIval = Parallel(textTrack, soundTrack)
self.perfectIval.start()
else:
taskMgr.doMethodLater(1, endGame, self.EndGameTaskName)
return
