def createSadInterval(self):
result = Sequence()
if self.hoodId in self.ZoneToSadAnims:
result = self.createAnimAndSoundIval('sad')
return result
def __init__(self):
ShowBase.__init__(self)
# Load the environment model.
self.environ = self.loader.loadModel("models/environment")
# self.environ is now a NodePath, or a handler for the node (the actual model)
# could load the same model several times with different NodePaths
# Reparent the NodePath to render, so the engine knows to show it in the scene.
self.environ.reparentTo(self.render)
# Apply scale and position transforms on the NodePath.
self.environ.setScale(0.25, 0.25, 0.25)
self.environ.setPos(-8, 42, 0)
# disable the mouse so it does not interfere with camera
base.disableMouse()
# set up some keyboard input
self.accept("escape", sys.exit) # Escape quits
self.accept("space", self.toggle_camera_spin) # spacebar
# set up a variable to keep track of camera toggle
self.spin_camera = True
# variable to keep track of total time spinning
self.spin_time = 0
# go ahead and start camera spinning
self.toggle_camera_spin()
# Load and transform the panda actor.
self.panda_actor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.panda_actor.setScale(0.005, 0.005, 0.005)
self.panda_actor.reparentTo(self.render)
# Loop the animation.
self.panda_actor.loop("walk")
# Create the four lerp intervals needed for the panda to
# walk back and forth.
panda_pos_interval1 = self.panda_actor.posInterval(13,
Point3(0, -10, 0),
startPos=Point3(
0, 10, 0))
panda_pos_interval2 = self.panda_actor.posInterval(13,
Point3(0, 10, 0),
startPos=Point3(
0, -10, 0))
panda_hpr_interval1 = self.panda_actor.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
0, 0, 0))
panda_hpr_interval2 = self.panda_actor.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
180, 0, 0))
# Create and play the sequence that coordinates the intervals.
self.panda_pace = Sequence(panda_pos_interval1,
panda_hpr_interval1,
panda_pos_interval2,
panda_hpr_interval2,
name="pandaPace")
self.panda_pace.loop()
# Add a smiley for fun.
self.smiley = self.loader.loadModel("models/smiley")
self.smiley.setPos(0, 0, 1)
self.smiley.reparentTo(self.render)
# velocity adjustment
self.vel_base = 3
# add task to allow smiley movement
self.taskMgr.add(self.game_loop_task, "GameLoop")
def doDeathTrack(self):
def removeDeathSuit(suit, deathSuit):
if not deathSuit.isEmpty():
deathSuit.detachNode()
suit.cleanupLoseActor()
self.deathSuit.reparentTo(self.suit.getParent())
self.deathSuit.setScale(self.suit.getScale())
self.deathSuit.setPos(render, self.suit.getPos(render))
self.deathSuit.setHpr(render, self.suit.getHpr(render))
self.suit.hide()
self.collNodePath.reparentTo(self.deathSuit)
gearPoint = Point3(0, 0, self.suit.height / 2.0 + 2.0)
smallGears = BattleParticles.createParticleEffect(
file='gearExplosionSmall')
singleGear = BattleParticles.createParticleEffect('GearExplosion',
numParticles=1)
smallGearExplosion = BattleParticles.createParticleEffect(
'GearExplosion', numParticles=10)
bigGearExplosion = BattleParticles.createParticleEffect(
'BigGearExplosion', numParticles=30)
smallGears.setPos(gearPoint)
singleGear.setPos(gearPoint)
smallGearExplosion.setPos(gearPoint)
bigGearExplosion.setPos(gearPoint)
smallGears.setDepthWrite(False)
singleGear.setDepthWrite(False)
smallGearExplosion.setDepthWrite(False)
bigGearExplosion.setDepthWrite(False)
suitTrack = Sequence(
Func(self.collNodePath.stash),
ActorInterval(self.deathSuit, 'lose', startFrame=80, endFrame=140),
Func(removeDeathSuit,
self.suit,
self.deathSuit,
name='remove-death-suit'))
explosionTrack = Sequence(
Wait(1.5),
MovieUtil.createKapowExplosionTrack(self.deathSuit,
explosionPoint=gearPoint))
gears1Track = Sequence(ParticleInterval(smallGears,
self.deathSuit,
worldRelative=0,
duration=4.3,
cleanup=True),
name='gears1Track')
gears2MTrack = Track((0.0, explosionTrack),
(0.7,
ParticleInterval(singleGear,
self.deathSuit,
worldRelative=0,
duration=5.7,
cleanup=True)),
(5.2,
ParticleInterval(smallGearExplosion,
self.deathSuit,
worldRelative=0,
duration=1.2,
cleanup=True)),
(5.4,
ParticleInterval(bigGearExplosion,
self.deathSuit,
worldRelative=0,
duration=1.0,
cleanup=True)),
name='gears2MTrack')
def removeParticle(particle):
if particle and hasattr(particle, 'renderParent'):
particle.cleanup()
del particle
removeParticles = Sequence(Func(removeParticle, smallGears),
Func(removeParticle, singleGear),
Func(removeParticle, smallGearExplosion),
Func(removeParticle, bigGearExplosion))
self.deathTrack = Sequence(
Parallel(suitTrack, gears2MTrack, gears1Track,
self._deathSoundIval), removeParticles)
self.deathTrack.start()
def showPrize(self, amt):
self.winSfx.play()
self.localAv.b_setAnimState('happy')
Sequence(Wait(3.5), Func(self.displayGameOver, 'showPrize',
amt)).start()
def __handleGameOverAck(self):
self.fsm.requestFinalState()
Sequence(Func(base.transitions.irisOut, 1.0), Wait(1.2),
Func(self.d_leaving),
Func(self.headBackToMinigameArea)).start()
def __animateEnv(self):
TTC = self.environ
toonHall = TTC.find('**/sz13:toon_landmark_TT_toonhall_DNARoot')
render.setPythonTag(
"ToonHall",
ToonHall(toonHall, toonHall.find('**/door_double_round_ur')))
phase_4 = 'phase_4/models/props/'
self.fish = TTC.find(
'**/animated_prop_PetShopFishAnimatedProp_DNARoot')
self.fish.removeNode()
self.fish = Actor(phase_4 + 'exteriorfish-zero.bam',
{'anim': phase_4 + 'exteriorfish-swim.bam'})
self.fish.reparentTo(
TTC.find('**/sz22:toon_landmark_TT_pet_shop_DNARoot'))
self.fish.loop('anim')
self.periscope = Actor(
TTC.find('**/animated_prop_HQPeriscopeAnimatedProp_DNARoot'),
copy=0)
self.periscope.reparentTo(render)
self.periscope.loadAnims(
{'anim': 'phase_3.5/models/props/HQ_periscope-chan.bam'})
self.periscope.pose('anim', 0)
self.periscopeTrack = Sequence(
Wait(2.0),
self.periscope.actorInterval('anim', startFrame=0, endFrame=40),
Wait(0.7),
self.periscope.actorInterval('anim', startFrame=40, endFrame=90),
Wait(0.7),
self.periscope.actorInterval('anim', startFrame=91, endFrame=121),
Wait(0.7),
self.periscope.actorInterval('anim', startFrame=121, endFrame=91),
Wait(0.7),
self.periscope.actorInterval('anim', startFrame=90, endFrame=40),
Wait(0.7),
self.periscope.actorInterval('anim', startFrame=40, endFrame=90),
Wait(0.7),
self.periscope.actorInterval('anim', startFrame=91, endFrame=121),
Wait(0.5),
self.periscope.actorInterval('anim', startFrame=121, endFrame=148),
Wait(3.0))
self.periscopeTrack.loop()
self.telescope = Actor(
TTC.find('**/animated_prop_HQTelescopeAnimatedProp_DNARoot'),
copy=0)
self.telescope.reparentTo(render)
self.telescope.loadAnims(
{'anim': 'phase_3.5/models/props/HQ_telescope-chan.bam'})
self.telescope.pose('anim', 0)
self.telescopeTrack = Sequence(
Wait(5.0),
self.telescope.actorInterval('anim', startFrame=0, endFrame=32),
Wait(0.5),
self.telescope.actorInterval('anim', startFrame=32, endFrame=78),
Wait(0.5),
self.telescope.actorInterval('anim', startFrame=79, endFrame=112),
Wait(0.5),
self.telescope.actorInterval('anim', startFrame=112, endFrame=79),
Wait(0.5),
self.telescope.actorInterval('anim', startFrame=78, endFrame=32),
Wait(0.5),
self.telescope.actorInterval('anim', startFrame=32, endFrame=78),
Wait(0.5),
self.telescope.actorInterval('anim', startFrame=79, endFrame=112),
Wait(0.5),
self.telescope.actorInterval('anim', startFrame=112, endFrame=148),
Wait(4.0))
self.telescopeTrack.loop()
#base.taskMgr.add(self.__moveClouds, "Move Clouds")
self.__fixTrashcans()
self.environ.flattenStrong()
self.scene.addModel(self.environ)
render.find('**/TTC').setPythonTag('Class', self)
def getSprayTrack(self,
origin,
target,
scaleUp,
hold,
scaleDown,
horizScale=1.0,
vertScale=1.0):
if self.sprayJoint.isEmpty():
self.build()
self.origin = self.getSprayStartPos()
base.localAvatar.stop(self.toonAnim)
self.lastFrame = self.avatar.getCurrentFrame(self.toonAnim)
track = Sequence()
sprayProp = loader.loadModel(GagGlobals.SPRAY_MDL)
sprayProp.setTwoSided(1)
sprayScale = hidden.attachNewNode('spray-parent')
sprayRot = hidden.attachNewNode('spray-rotate')
sprayRot.setColor(GagGlobals.WATER_SPRAY_COLOR)
sprayRot.setTransparency(1)
collNode = CollisionNode('Collision')
spraySphere = CollisionSphere(0, 0, 0, 1)
spraySphere.setTangible(0)
collNode.addSolid(spraySphere)
collNode.setCollideMask(CIGlobals.WallBitmask)
sprayNP = sprayRot.attachNewNode(collNode)
sprayNP.setY(1)
self.sprayNP = sprayNP
event = CollisionHandlerEvent()
event.set_in_pattern("%fn-into")
event.set_out_pattern("%fn-out")
base.cTrav.add_collider(sprayNP, event)
self.avatar.acceptOnce(sprayNP.node().getName() + '-into',
self.onCollision)
def showSpray(sprayScale, sprayProp, origin, target):
objects = [sprayRot, sprayScale, sprayProp]
for item in objects:
index = objects.index(item)
if index == 0:
item.reparentTo(self.sprayJoint)
item.setPos(0, 0, 0)
item.setHpr(self.sprayRotation)
item.wrtReparentTo(render)
else:
item.reparentTo(objects[index - 1])
track.append(Func(showSpray, sprayScale, sprayProp, origin, target))
self.spray = sprayRot
def calcTargetScale():
distance = Vec3(target - origin).length()
yScale = distance / GagGlobals.SPRAY_LEN
targetScale = Point3(yScale * horizScale, yScale,
yScale * vertScale)
return targetScale
track.append(
Parallel(
LerpScaleInterval(sprayScale,
scaleUp,
calcTargetScale,
startScale=GagGlobals.PNT3NEAR0),
sprayNP.posInterval(
0.25,
self.spray.getPos(render) + Point3(0, 50, 0),
startPos=self.spray.getPos(render) + Point3(0, 5, 0))))
track.append(Wait(hold))
track.append(Func(self.handleMiss))
track.append(LerpScaleInterval(sprayScale, 0.75, GagGlobals.PNT3NEAR0))
def hideSpray():
lambda prop: prop.removeNode(), [sprayProp, sprayRot, sprayScale]
track.append(Func(hideSpray))
track.append(Func(self.completeSquirt))
return track
def accomodateToon(self, toon):
toon.wrtReparentTo(self.root)
toon.setPos(self.toonGolfOffsetPos)
toon.setHpr(self.toonGolfOffsetHpr)
return Sequence()
def getFlyBallSplatInterval(self, x, y, z, flyBallCode, throwerId):
from toontown.toonbase import ToontownBattleGlobals
from toontown.battle import BattleProps
splatName = 'dust'
splat = BattleProps.globalPropPool.getProp(splatName)
splat.setBillboardPointWorld(2)
color = ToontownGlobals.PieCodeColors.get(flyBallCode)
if color:
splat.setColor(*color)
if flyBallCode == ToontownGlobals.PieCodeBossCog:
self.notify.debug('changing color to %s' % self.ballColor)
splat.setColor(self.ballColor)
sound = loader.loadSfx('phase_11/audio/sfx/LB_evidence_miss.mp3')
vol = 1.0
if flyBallCode == ToontownGlobals.PieCodeBossCog:
sound = loader.loadSfx('phase_4/audio/sfx/Golf_Hit_Barrier_1.mp3')
soundIval = SoundInterval(sound, node=splat, volume=vol)
if flyBallCode == ToontownGlobals.PieCodeBossCog and localAvatar.doId == throwerId:
vol = 1.0
soundIval = SoundInterval(sound, node=localAvatar, volume=vol)
ival = Parallel(Func(splat.reparentTo, render), Func(splat.setPos, x, y, z), soundIval, Sequence(ActorInterval(splat, splatName), Func(splat.detachNode)))
return ival
def __allowDetect(self, task):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = Sequence(self.tableGroup.colorScaleInterval(0.2, VBase4(1, 1, 1, 1)), Func(self.tableGroup.clearColorScale), Func(self.tableGroup.clearTransparency))
self.fadeTrack.start()
self.allowLocalRequestControl = True
def getRestoreScaleInterval(self):
return Sequence()
def createVictoryInterval(self):
result = Sequence()
if self.hoodId in self.ZoneToVictoryAnims:
animAndSoundIval = self.createAnimAndSoundIval('victory')
result.append(animAndSoundIval)
return result
def getOverrideIval(self, origAnimName): return Sequence()
def getSpecialIval(self, origAnimName): return Sequence()
def postInit(self):
#
# initialize game content
#
# Menus
self.mainmenu = Mainmenu()
self.optionsmenu = Optionsmenu()
self.loadingscreen = LoadingScreen()
self.music_menu = loader.loadMusic("music/menu.ogg")
self.music_menu.setLoop(True)
self.music_game = loader.loadMusic("music/game.ogg")
self.music_game.setLoop(True)
self.music_intro = loader.loadMusic("music/logos.ogg")
# The games Intro
def create16To9LogoCard(logoPath, tsName):
cm = CardMaker("fade")
scale = abs(base.a2dLeft) / 1.7776
cm.setFrame(-1, 1, -1 * scale, 1 * scale)
logo = NodePath(cm.generate())
logo.setTransparency(TransparencyAttrib.MAlpha)
logoTex = loader.loadTexture(logoPath)
logoTs = TextureStage(tsName)
logoTs.setMode(TextureStage.MReplace)
logo.setTexture(logoTs, logoTex)
logo.setBin("fixed", 5000)
logo.reparentTo(render2d)
logo.hide()
return logo
self.gfLogo = create16To9LogoCard("intro/GrimFangLogo.png", "gfLogoTS")
self.pandaLogo = create16To9LogoCard("intro/Panda3DLogo.png",
"pandaLogoTS")
self.gameLogo = create16To9LogoCard("intro/GameLogo.png", "gameLogoTS")
def createFadeIn(logo):
return LerpColorScaleInterval(logo, 2,
LVecBase4f(0.0, 0.0, 0.0, 1.0),
LVecBase4f(0.0, 0.0, 0.0, 0.0))
def createFadeOut(logo):
return LerpColorScaleInterval(logo, 2,
LVecBase4f(0.0, 0.0, 0.0, 0.0),
LVecBase4f(0.0, 0.0, 0.0, 1.0))
gfFadeInInterval = createFadeIn(self.gfLogo)
gfFadeOutInterval = createFadeOut(self.gfLogo)
p3dFadeInInterval = createFadeIn(self.pandaLogo)
p3dFadeOutInterval = createFadeOut(self.pandaLogo)
gameFadeInInterval = createFadeIn(self.gameLogo)
gameFadeOutInterval = createFadeOut(self.gameLogo)
self.introFadeInOutSequence = Sequence(Func(self.music_intro.play),
Func(self.gfLogo.show),
gfFadeInInterval,
Wait(1.0),
gfFadeOutInterval,
Wait(0.5),
Func(self.gfLogo.hide),
Func(self.pandaLogo.show),
p3dFadeInInterval,
Wait(1.0),
p3dFadeOutInterval,
Wait(0.5),
Func(self.pandaLogo.hide),
Func(self.gameLogo.show),
gameFadeInInterval,
Wait(1.0),
gameFadeOutInterval,
Wait(0.5),
Func(self.gameLogo.hide),
Func(self.messenger.send,
"intro_done"),
Func(self.music_intro.stop),
name="fadeInOut")
# game intro end
# collision setup
base.cTrav = CollisionTraverser("base collision traverser")
base.cTrav.setRespectPrevTransform(True)
# setup default physics
base.enableParticles()
#
# Event handling
#
self.accept("escape", self.__escape)
# accept menu events
self.accept("menu_start", self.request, ["Game"])
self.accept("menu_options", self.request, ["Options"])
self.accept("menu_quit", self.quit)
self.accept("options_back", self.request, ["Menu"])
# game over
self.accept("GameOver", self.demand, ["Menu"])
#
# Start with the menu after the intro has been played
#
self.introFadeInOutSequence.start()
self.accept("intro_done", self.request, ["Menu"])
def ride_elevator_up(self):
self.play('exit', ['hobot', 'elevator'], extra_interval=Sequence(Wait(3.0), Func(self.hide_scene_hobot)), callback=base.next_floor, sound=self.sfx["exit"])
def showSuitsFalling(self, suits, ts, name, callback):
assert (len(suits) > 0)
if self.bossCog == None:
# Hmm, no boss cog? Maybe not generated yet.
return
suitTrack = Parallel()
delay = 0
for suit in suits:
"""
This is done by the AI now.
if self.battleNumber == 2:
# Battle 2 features skelecogs only.
suit.makeSkeleton()
suit.corpMedallion.hide()
suit.healthBar.show()
"""
suit.makeWaiter()
suit.setState('Battle')
#RAU lawbot boss battle hack,
if suit.dna.dept == 'l':
suit.reparentTo(self.bossCog)
suit.setPos(0, 0, 0)
#suit.setScale(3.8 / suit.height)
# Move all suits into position
if suit in self.joiningSuits:
i = len(self.pendingSuits) + self.joiningSuits.index(suit)
destPos, h = self.suitPendingPoints[i]
destHpr = VBase3(h, 0, 0)
else:
destPos, destHpr = self.getActorPosHpr(suit, self.suits)
startPos = destPos + Point3(
0, 0, (SuitTimings.fromSky * ToontownGlobals.SuitWalkSpeed))
self.notify.debug('startPos for %s = %s' % (suit, startPos))
suit.reparentTo(self)
suit.setPos(startPos)
suit.headsUp(self)
flyIval = suit.beginSupaFlyMove(destPos, True, 'flyIn')
suitTrack.append(
Track(
#(delay, self.createAdjustInterval(suit, destPos, destHpr)),
(delay, Sequence(flyIval, Func(suit.loop, 'neutral')))))
delay += 1
if (self.hasLocalToon()):
# Parent the camera to the battle and position it to watch the
# suits join.
camera.reparentTo(self)
# Choose either a left or a right view at random.
if random.choice([0, 1]):
camera.setPosHpr(20, -4, 7, 60, 0, 0)
else:
camera.setPosHpr(-20, -4, 7, -60, 0, 0)
done = Func(callback)
track = Sequence(suitTrack, done, name=name)
track.start(ts)
self.storeInterval(track, name)
def setHillType(self, type):
self.hillType = type
self.moleHead.removeNode()
if type == MoleFieldBase.HILL_MOLE:
self.moleHead = loader.loadModel(
'phase_12/models/bossbotHQ/mole_norm')
self.moleColNodePath.setScale(3.0)
self.moleHead.setH(0)
else:
if type == MoleFieldBase.HILL_WHACKED:
self.moleHead = loader.loadModel(
'phase_12/models/bossbotHQ/mole_hit')
self.mole.setBillboardAxis(0)
self.moleColNodePath.setScale(0.0)
if self.popIval:
self.popIval.finish()
if self.downIval:
self.downIval.finish()
self.mole.setPos(0.0, 0.0, 0.0)
self.popIval = Sequence(
Parallel(
Sequence(
LerpPosInterval(self.moleHead, 0.05,
Point3(0.18, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, -0.13, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.18)),
LerpPosInterval(self.moleHead, 0.05,
Point3(-0.15, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.18, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.11, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, -0.12, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.18)),
LerpPosInterval(self.moleHead, 0.05,
Point3(-0.18, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.13, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.18, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, -0.15, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.18)),
LerpPosInterval(self.moleHead, 0.05,
Point3(-0.16, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.18, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.11, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, -0.18, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.17)),
LerpPosInterval(self.moleHead, 0.05,
Point3(-0.18, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.0))),
Sequence(LerpScaleInterval(self.moleHead, 0.5, 3.5),
LerpScaleInterval(self.moleHead, 0.5, 1.0))),
LerpPosInterval(self.mole, 0.5, Point3(0, 0, -2.5)),
Func(self.setHillType, MoleFieldBase.HILL_MOLE))
self.popIval.start()
self.moleHead.reparentTo(self.mole)
def getSprayTrack(self,
color,
origin,
target,
dScaleUp,
dHold,
dScaleDown,
horizScale=1.0,
vertScale=1.0,
parent=render):
track = Sequence()
SPRAY_LEN = 1.5
sprayProp = MovieUtil.globalPropPool.getProp('spray')
sprayScale = hidden.attachNewNode('spray-parent')
sprayRot = hidden.attachNewNode('spray-rotate')
spray = sprayRot
spray.setColor(color)
if color[3] < 1.0:
spray.setTransparency(1)
def showSpray(sprayScale, sprayRot, sprayProp, origin, target, parent):
if callable(origin):
origin = origin()
if callable(target):
target = target()
sprayRot.reparentTo(parent)
sprayRot.clearMat()
sprayScale.reparentTo(sprayRot)
sprayScale.clearMat()
sprayProp.reparentTo(sprayScale)
sprayProp.clearMat()
sprayRot.setPos(origin)
sprayRot.lookAt(Point3(target))
track.append(
Func(showSpray, sprayScale, sprayRot, sprayProp, origin, target,
parent))
def calcTargetScale(target=target,
origin=origin,
horizScale=horizScale,
vertScale=vertScale):
if callable(target):
target = target()
if callable(origin):
origin = origin()
distance = Vec3(target - origin).length()
yScale = distance / SPRAY_LEN
targetScale = Point3(yScale * horizScale, yScale,
yScale * vertScale)
return targetScale
track.append(
LerpScaleInterval(sprayScale,
dScaleUp,
calcTargetScale,
startScale=Point3(0.01, 0.01, 0.01)))
track.append(Func(self.checkHitObject))
track.append(Wait(dHold))
def prepareToShrinkSpray(spray, sprayProp, origin, target):
if callable(target):
target = target()
if callable(origin):
origin = origin()
sprayProp.setPos(Point3(0.0, -SPRAY_LEN, 0.0))
spray.setPos(target)
track.append(
Func(prepareToShrinkSpray, spray, sprayProp, origin, target))
track.append(
LerpScaleInterval(sprayScale, dScaleDown, Point3(0.01, 0.01,
0.01)))
def hideSpray(spray, sprayScale, sprayRot, sprayProp, propPool):
sprayProp.detachNode()
MovieUtil.removeProp(sprayProp)
sprayRot.removeNode()
sprayScale.removeNode()
track.append(
Func(hideSpray, spray, sprayScale, sprayRot, sprayProp,
MovieUtil.globalPropPool))
return track
def splitBoard(self):
self.sawingLine.reset()
board = self.currentBoard
boardIndex = self.currentBoardIndex
if self.hitZone2Penalty:
boardSplitAnim = Parallel(
LerpPosInterval(self.board_left,
duration=self.config.splitBoardAnimTime,
pos=Point3(-2.0, 0.0, 0.0)),
LerpPosInterval(self.board_right,
duration=self.config.splitBoardAnimTime,
pos=Point3(2.0, 0.0, 0.0)),
LerpFunc(self.zone2_left.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.zone2_right.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.zone1_left.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.zone1_right.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.cut.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0))
elif self.hitZone1Penalty:
boardSplitAnim = Parallel(
LerpPosInterval(self.board_left,
duration=self.config.splitBoardAnimTime,
pos=Point3(-2.0, 0.0, 0.0)),
LerpPosInterval(self.board_right,
duration=self.config.splitBoardAnimTime,
pos=Point3(2.0, 0.0, 0.0)),
LerpPosInterval(self.zone2_left,
duration=self.config.splitBoardAnimTime,
pos=Point3(-2.0, 0.0, 0.0)),
LerpPosInterval(self.zone2_right,
duration=self.config.splitBoardAnimTime,
pos=Point3(2.0, 0.0, 0.0)),
LerpFunc(self.zone1_left.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.zone1_right.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0),
LerpFunc(self.cut.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0))
else:
boardSplitAnim = Parallel(
LerpPosInterval(self.piece1,
duration=self.config.splitBoardAnimTime,
pos=Point3(-2.0, self.config.boardYDist, 0.0)),
LerpPosInterval(self.piece2,
duration=self.config.splitBoardAnimTime,
pos=Point3(2.0, self.config.boardYDist, 0.0)),
LerpFunc(self.cut.setSa,
duration=self.config.splitBoardAnimTime / 2.0,
fromData=1.0,
toData=0.0))
self.splitBoardSequence = Sequence(
Func(self.updateScore),
Func(self.boardComplete.play),
boardSplitAnim,
Func(board.stash),
Func(self.piece1.setPos, self.piece1.getPos()),
Func(self.piece2.setPos, self.piece2.getPos()),
Func(self.board_right.setPos, self.board_right.getPos()),
Func(self.board_left.setPos, self.board_left.getPos()),
Func(self.zone2_right.setPos, self.zone2_right.getPos()),
Func(self.zone2_left.setPos, self.zone2_left.getPos()),
Func(self.zone1_right.setPos, self.zone1_right.getPos()),
Func(self.zone1_left.setPos, self.zone1_left.getPos()),
Func(self.cut.setSa, 1.0),
Func(self.zone1_right.setSa, 1.0),
Func(self.zone1_left.setSa, 1.0),
Func(self.zone2_right.setSa, 1.0),
Func(self.zone2_left.setSa, 1.0),
Func(self.board_right.setSa, 1.0),
Func(self.board_left.setSa, 1.0),
Func(self.loadNewBoard),
Func(self.addBoardBackToPool, board, boardIndex),
name='RepairSawGame.splitBoardSequence')
self.splitBoardSequence.start()
def winner(self):
self.winSfx.play()
self.localAv.b_setAnimState('happy')
Sequence(Wait(3.5), Func(self.displayGameOver, 'winner')).start()
def loadNewBoard(self):
self.progressLabel.stash()
self.progressDescriptionLabel.stash()
if self.totalScore >= self.config.totalPoints:
if self.onDeckBoard:
self.onDeckBoard.stash()
self.progressDescriptionLabel.stash()
taskMgr.remove('SawingGame.updateSawTask')
self.request('Outro')
return
self.currentBoard = self.onDeckBoard
self.currentBoardIndex = self.onDeckBoardIndex
self.piece1 = self.currentBoard.find('**/piece_1')
self.piece1.setTransparency(1)
self.piece2 = self.currentBoard.find('**/piece_2')
self.piece2.setTransparency(1)
self.cut = self.currentBoard.find('**/piece_cut')
self.cut.setColor(self.config.cutColor)
self.cut.setTransparency(1)
self.board_left = self.piece1.find('**/board')
self.board_left.setTransparency(1)
self.zone1_left = self.piece1.find('**/zone_1')
self.zone1_left.setTransparency(1)
self.zone2_left = self.piece1.find('**/zone_2')
self.zone2_left.setTransparency(1)
self.board_right = self.piece2.find('**/board')
self.board_right.setTransparency(1)
self.zone1_right = self.piece2.find('**/zone_1')
self.zone1_right.setTransparency(1)
self.zone2_right = self.piece2.find('**/zone_2')
self.zone2_right.setTransparency(1)
self.board_left.setCollideMask(SAW_COLLIDE_MASK)
self.board_right.setCollideMask(SAW_COLLIDE_MASK)
self.cut.setCollideMask(SAW_COLLIDE_MASK)
self.zone1_right.setCollideMask(SAW_COLLIDE_MASK)
self.zone1_left.setCollideMask(SAW_COLLIDE_MASK)
self.zone2_right.setCollideMask(SAW_COLLIDE_MASK)
self.zone2_left.setCollideMask(SAW_COLLIDE_MASK)
self.startPositions = (
self.currentBoard.find('**/locator_start_0').getPos() +
Point3(*self.config.activeBoardPosition),
self.currentBoard.find('**/locator_start_1').getPos() +
Point3(*self.config.activeBoardPosition))
self.currentStartIndex = 0
for waypoint in self.sawWaypoints:
waypoint.removeNode()
self.sawWaypoints = []
locator = self.currentBoard.find('**/locator_0')
index = 0
while not locator.isEmpty():
self.sawWaypoints.append(
SawWaypoint(index, self.currentBoard, locator.getPos()))
locator = self.currentBoard.find('**/locator_%i' % (index + 1))
index += 1
self.sawButton.deactivate()
self.sawButton.setPos(self.startPositions[self.currentStartIndex])
self.hitBoardPenalty = False
self.hitZone1Penalty = False
self.hitZone2Penalty = False
self.lastMousePos = None
self.moveDiffForSound = self.config.playSawingSoundDelta + 0.1
self.newBoardSequence = Sequence(
Parallel(
self.currentBoard.posInterval(
self.config.newBoardAnimTime,
Point3(*self.config.activeBoardPosition)),
self.currentBoard.scaleInterval(self.config.newBoardAnimTime,
1.0)),
name='RepairSawingGame.newBoardSequence')
if self.state in ['Game']:
self.newBoardSequence.append(Func(self.sawButton.activate))
self.newBoardSequence.append(Wait(0.5))
self.newBoardSequence.append(Func(self.moveNewBoardOnDeck))
self.newBoardSequence.start()
return
def loser(self):
self.loseSfx.play()
self.localAv.b_setAnimState('neutral')
Sequence(Wait(3.5), Func(self.displayGameOver, 'loser')).start()
def cameraMovement(self, task):
if hasattr(self, 'min_camerap') and hasattr(
self, 'max_camerap') and base.mouseWatcherNode.hasMouse():
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
centerX = base.win.getXSize() / 2
centerY = base.win.getYSize() / 2
base.win.movePointer(0, centerX, centerY)
# Get the mouse sensitivity
sens = CIGlobals.getSettingsMgr().getSetting("fpmgms").getValue()
dt = globalClock.getDt()
# Do some mouse movement
goalH = self.player_node.getH() - (x - centerX) * sens
self.player_node.setH(goalH)
goalP = self.player_node.getP() - (y - centerY) * sens
if goalP < self.min_camerap:
goalP = self.min_camerap
elif goalP > self.max_camerap:
goalP = self.max_camerap
self.player_node.setP(goalP)
self.geomNodeRenderYaw = base.localAvatar.getGeomNode().getH(
render)
if base.localAvatar.isMoving():
# We can turn our character with the mouse while moving.
oldH = base.localAvatar.getH(render)
base.localAvatar.walkControls.rotationSpeed = abs(
oldH - base.localAvatar.getH(render)) / 1.5
base.localAvatar.setH(render, self.player_node.getH(render))
self.player_node.setH(0)
spine = base.localAvatar.find("**/def_cageA")
if not spine.isEmpty():
spine.setH(0)
spine.setP(render, self.player_node.getP(render))
spine.setR(0)
if self.firstTimeMoving:
self.firstTimeMoving = False
base.localAvatar.getGeomNode().setH(
render, self.geomNodeRenderYaw)
if self.geomNodeTurnIval:
self.geomNodeTurnIval.finish()
self.geomNodeTurnIval = None
distance = (base.localAvatar.getGeomNode().getH() % 360)
if distance > 180:
distance = 360 - distance
self.geomNodeTurnIval = Sequence(
Func(base.localAvatar.setForceRunSpeed, True),
LerpHprInterval(
base.localAvatar.getGeomNode(),
duration=distance / self.GeomNodeTurnSpeed,
hpr=(0, 0, 0),
startHpr=base.localAvatar.getGeomNode().getHpr()),
Func(base.localAvatar.setForceRunSpeed, False))
self.geomNodeTurnIval.start()
elif not base.localAvatar.isMoving(
) and base.localAvatar.smartCamera.isOverTheShoulder():
oldH = base.localAvatar.getH(render)
base.localAvatar.walkControls.rotationSpeed = abs(
oldH - base.localAvatar.getH(render)) / 1.5
spine = base.localAvatar.find("**/def_cageA")
if not spine.isEmpty():
spine.setH(render, self.player_node.getH(render))
spine.setP(render, self.player_node.getP(render))
spine.setR(0)
discrep = abs(
spine.getH(render) - base.localAvatar.getH(render))
if discrep > self.MaxSpineLegsDiscrepency:
spine.setHpr(0, 0, 0)
base.localAvatar.setH(render,
self.player_node.getH(render))
self.player_node.setH(0)
else:
self.firstTimeMoving = True
return task.cont
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 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, 50),
gravMult=0.55)
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),
Wait(CTGG.LyingDownDuration - (flyDur - oldFlyDur)),
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 addLine(self, text, color):
# Whilst in a battle, we don't want to display update text.
if base.localAvatarReachable():
place = base.cr.playGame.getPlace()
if base.localAvatar.getBattleZone() or (
place and place.fsm.getCurrentState().getName() != 'walk'):
self.queuedLines[text] = color
return
if len(self.lines) == self.MAX_LINES:
oldestLine = self.lines[len(self.lines) - 1]
ival = self.ivalDict.get(oldestLine, None)
ival.finish()
newLine = OnscreenText(parent=self,
text=text,
fg=color,
shadow=(color[0] * self.SHADOW_MODIFIER,
color[1] * self.SHADOW_MODIFIER,
color[2] * self.SHADOW_MODIFIER, 1.0),
mayChange=1,
font=CIGlobals.getMinnieFont())
newLine.setPos(*self.LINE_MINIMUM_POS)
initScale = (1.0, 1.0, 1.0)
growScale = (1.15, 1.15, 1.15)
"""
LerpScaleInterval(newLine, 0.5,
scale = initScale,
blendType = 'easeIn',
bakeInStart = 0),
"""
lineIval = Sequence(
Func(self.alertSfx.play),
LerpScaleInterval(newLine,
0.5,
scale=initScale,
startScale=(0.01, 0.01, 0.01),
blendType='easeOut',
bakeInStart=0), Wait(0.5),
Wait(self.SHOW_DURATION),
Parallel(
LerpPosInterval(newLine,
self.FADE_DURATION,
pos=(0.0, 0.0, (self.LINE_Y_OFFSET *
(self.MAX_LINES + 1.8))),
blendType='easeIn',
bakeInStart=0,
other=self),
LerpColorScaleInterval(newLine,
self.FADE_DURATION - 0.5,
(1.0, 1.0, 1.0, 0.01),
blendType='easeIn')),
Func(self.deleteLine, newLine))
self.lines.insert(0, newLine)
self.ivalDict.update({newLine: lineIval})
for i in range(1, len(self.lines)):
line = self.lines[i]
if not line.isEmpty():
# Let's reposition this element.
line.setPos(
line.getX(),
self.LINE_MINIMUM_POS[1] + (self.LINE_Y_OFFSET * i))
lineIval.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 getDropIval(self):
shadow = self.shadow
drop = self.drop
id = self.id
hangTime = Globals.ShadowTime
dropTime = Globals.DropTime
dropHeight = Globals.DropHeight
targetShadowScale = 0.5
targetShadowAlpha = 0.4
shadowScaleIval = LerpScaleInterval(shadow,
dropTime,
targetShadowScale,
startScale=0)
shadowAlphaIval = LerpColorScaleInterval(
shadow,
hangTime,
Point4(1, 1, 1, targetShadowAlpha),
startColorScale=Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
startPos = Point3(0, 0, dropHeight)
drop.setPos(startPos)
dropIval = LerpPosInterval(drop,
dropTime,
Point3(0, 0, 0),
startPos=startPos,
blendType='easeIn')
dropSoundIval = self._dropSfx
dropSoundIval.node = self
self.drop.setTransparency(1)
def _setRandScale(t):
self.drop.setScale(self, 1 - random.random() / 16,
1 - random.random() / 16,
1 - random.random() / 4)
scaleChange = 0.4 + random.random() / 4
dropShakeSeq = Sequence(
LerpScaleInterval(self.drop,
0.25,
Vec3(1.0 + scaleChange, 1.0 + scaleChange / 2,
1.0 - scaleChange),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.25,
Vec3(1.0, 1.0, 1.0),
blendType='easeInOut'),
Func(self.disableCollisionDamage),
LerpScaleInterval(self.drop,
0.2,
Vec3(1.0 + scaleChange / 8,
1.0 + scaleChange / 8,
1.0 - scaleChange / 8),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.2,
Vec3(1.0, 1.0, 1.0),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.15,
Vec3(1.0 + scaleChange / 16,
1.0 + scaleChange / 16,
1.0 - scaleChange / 16),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.15,
Vec3(1.0, 1.0, 1.0),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.1,
Vec3(1.0 + scaleChange / 16,
1.0 + scaleChange / 8,
1.0 - scaleChange / 16),
blendType='easeInOut'),
LerpColorScaleInterval(self.drop, Globals.DropFadeTime,
Vec4(1.0, 1.0, 1.0, 0.0)))
ival = Sequence(Func(self.reparentTo, render),
Parallel(Sequence(WaitInterval(hangTime), dropIval),
shadowIval),
Parallel(Func(self.game.dropHit, self, id),
dropSoundIval, dropShakeSeq),
Func(self.game.cleanupDrop, id),
name='drop%s' % id)
self.ival = ival
return ival
def __init__(self):
ShowBase.__init__(self)
walls = {}
pivots = {}
rotations = {}
position = {}
cubeMembership = {}
#Equator slice is the slice between up and down faces, center slice between left and right faces, standing slice the left one,
wallIDs = ("front", "back", "left", "right", "down", "up", "equator",
"center", "standing")
hprs = {}
# VBase(Z,X,Y) if spin around Z, VBase3(90., 0., 0.).
# The degree is positive following the right hand rule.
hprs["right"] = VBase3(0., -90., 0.)
hprs["center"] = VBase3(
0., -90., 0.
) # The ratation direction of the standing slice follows the front face.
hprs["left"] = VBase3(0., 90., 0.)
hprs["back"] = VBase3(0., 0., -90.)
hprs["front"] = VBase3(0., 0., 90.)
hprs["standing"] = VBase3(
0., 0., 90.
) # The ratation direction of the center slice follows the right face.
hprs["down"] = VBase3(90., 0., 0.)
hprs["up"] = VBase3(-90., 0., 0.)
hprs["equator"] = VBase3(
-90., 0., 0.
) # The ratation direction of the equator slice follows the up face.
wallRotate = {}
wallNegRotate = {}
# Each rotation is a matrix.
# The positive front rotation and the negative back rotation have the same matrix.
# The standing slice follows the rules of the front face.
wallRotate["right"] = wallRotate["center"] = wallNegRotate["left"] = [[
1, 0, 0
], [0, 0, -1], [0, 1, 0]]
wallRotate["left"] = wallNegRotate["right"] = wallNegRotate[
"center"] = [[1, 0, 0], [0, 0, 1], [0, -1, 0]]
wallRotate["back"] = wallNegRotate["standing"] = wallNegRotate[
"front"] = [[0, 0, 1], [0, 1, 0], [-1, 0, 0]]
wallRotate["front"] = wallRotate["standing"] = wallNegRotate[
"back"] = [[0, 0, -1], [0, 1, 0], [1, 0, 0]]
wallRotate["up"] = wallRotate["equator"] = wallNegRotate["down"] = [[
0, -1, 0
], [1, 0, 0], [0, 0, 1]]
wallRotate["down"] = wallNegRotate["equator"] = wallNegRotate["up"] = [
[0, 1, 0], [-1, 0, 0], [0, 0, 1]
]
for wallID in wallIDs:
walls[wallID] = []
pivots[wallID] = self.render.attachNewNode('pivot_%s' % wallID)
rotations[wallID] = {"hpr": hprs[wallID]}
#print walls
#print pivots
#print rotations
for x in (-1, 0, 1):
for y in (-1, 0, 1):
for z in (-1, 0, 1):
createCube(self.render, x, y, z, position, cubeMembership,
walls)
self.directionalLight = DirectionalLight('directionalLight')
self.directionalLightNP = self.cam.attachNewNode(self.directionalLight)
self.directionalLightNP.setHpr(20., -20., 0.)
self.render.setLight(self.directionalLightNP)
self.cam.setPos(7., -10., 4.)
self.cam.lookAt(0., 0., 0.)
def reparentCubes(wallID):
pivot = pivots[wallID]
children = pivot.getChildren()
children.wrtReparentTo(self.render)
pivot.clearTransform()
children.wrtReparentTo(pivot)
for cube in walls[wallID]:
cube.wrtReparentTo(pivot)
def updateCubeMembership(wallID, negRotation=False):
for cube in walls[wallID]:
oldMembership = cubeMembership[cube]
# print "oldMembership",oldMembership
# print "old position", position[cube]
newMembership = set()
cubeMembership[cube] = newMembership
# X cordinate
newPos = 0
if not negRotation:
for j in range(3):
newPos = newPos + int(position[cube][j]) * int(
wallRotate[wallID][j][0])
else:
for j in range(3):
newPos = newPos + int(position[cube][j]) * int(
wallNegRotate[wallID][j][0])
if newPos == 1:
newMembership.add("right")
elif newPos == -1:
newMembership.add("left")
elif newPos == 0:
newMembership.add("center")
newPosX = newPos
# Y cordinate
newPos = 0
if not negRotation:
for j in range(3):
newPos = newPos + int(position[cube][j]) * int(
wallRotate[wallID][j][1])
else:
for j in range(3):
newPos = newPos + int(position[cube][j]) * int(
wallNegRotate[wallID][j][1])
if newPos == 1:
newMembership.add("back")
elif newPos == -1:
newMembership.add("front")
elif newPos == 0:
newMembership.add("standing")
newPosY = newPos
# Z cordinate
newPos = 0
if not negRotation:
for j in range(3):
newPos = newPos + int(position[cube][j]) * int(
wallRotate[wallID][j][2])
else:
for j in range(3):
newPos = newPos + int(position[cube][j]) * int(
wallNegRotate[wallID][j][2])
if newPos == 1:
newMembership.add("up")
elif newPos == -1:
newMembership.add("down")
elif newPos == 0:
newMembership.add("equator")
newPosZ = newPos
position[cube] = [newPosX, newPosY, newPosZ]
# print "newMembership",newMembership
# print "new position:", position[cube]
for oldWallID in oldMembership - newMembership:
walls[oldWallID].remove(cube)
for newWallID in newMembership - oldMembership:
walls[newWallID].append(cube)
self.seq = Sequence()
def addInterval(wallID, negRotation=False):
self.seq.append(Func(reparentCubes, wallID))
rot = rotations[wallID]["hpr"]
if negRotation:
rot = rot * -1.
#Revision: 1.0 is the speed of rotation, 2.5 is slower.
self.seq.append(LerpHprInterval(pivots[wallID], 1.0, rot))
self.seq.append(Func(updateCubeMembership, wallID, negRotation))
# print "Added " + ("negative " if negRotation else "") + wallID + " rotation."
def acceptInput(
): # Revision: top-->up, bottom-->down. Reverse rotation: back,up,right
# <F> adds a positive Front rotation
self.accept("f", lambda: addInterval("front"))
# <Shift+F> adds a negative Front rotation
self.accept("shift-f", lambda: addInterval("front", True))
# <B> adds a positive Back rotation
self.accept("b", lambda: addInterval("back"))
# <Shift+B> adds a negative Back rotation
self.accept("shift-b", lambda: addInterval("back", True))
# <L> adds a positive Left rotation
self.accept("l", lambda: addInterval("left"))
# <Shift+L> adds a negative Left rotation
self.accept("shift-l", lambda: addInterval("left", True))
# <R> adds a positive Right rotation
self.accept("r", lambda: addInterval("right"))
# <Shift+R> adds a negative Right rotation
self.accept("shift-r", lambda: addInterval("right", True))
# <D> adds d positive Down rotation
self.accept("d", lambda: addInterval("down"))
# <Shift+D> adds a negative Down rotation
self.accept("shift-d", lambda: addInterval("down", True))
# <U> adds a positive Up rotation
self.accept("u", lambda: addInterval("up"))
# <Shift+U> adds a negative Up rotation
self.accept("shift-u", lambda: addInterval("up", True))
# Rivision: to rotate the center slice
# <C> adds a positive Back rotation
self.accept("c", lambda: addInterval("center"))
# <Shift+C> adds a negative Back rotation
self.accept("shift-c", lambda: addInterval("center", True))
# Rivision: to rotate the equator slice
# <E> adds a positive Back rotation
self.accept("e", lambda: addInterval("equator"))
# <Shift+E> adds a negative Back rotation
self.accept("shift-e", lambda: addInterval("equator", True))
# Rivision: to rotate the standing slice
# <S> adds a positive Back rotation
self.accept("s", lambda: addInterval("standing"))
# <Shift+S> adds a negative Back rotation
self.accept("shift-s", lambda: addInterval("standing", True))
# <Enter> starts the sequence
self.accept("enter", startSequence)
def ignoreInput():
self.ignore("f")
self.ignore("shift-f")
self.ignore("b")
self.ignore("shift-b")
self.ignore("l")
self.ignore("shift-l")
self.ignore("r")
self.ignore("shift-r")
self.ignore("d")
self.ignore("shift-d")
self.ignore("u")
self.ignore("shift-u")
self.ignore("enter")
def startSequence():
# do not allow input while the sequence is playing...
ignoreInput()
# ...but accept input again once the sequence is finished
self.seq.append(Func(acceptInput))
self.seq.start()
# print "Sequence started."
# create a new sequence, so no new intervals will be appended to the started one
self.seq = Sequence()
acceptInput()
