def __healDance(heal, hasInteractivePropHealBonus):
npcId = 0
if "npcId" in heal:
npcId = heal["npcId"]
toon = NPCToons.createLocalNPC(npcId)
if toon == None:
return
else:
toon = heal["toon"]
targets = heal["target"]
ineffective = heal["sidestep"]
level = heal["level"]
if npcId != 0:
track = Sequence(MovieNPCSOS.teleportIn(heal, toon))
else:
track = Sequence(__runToHealSpot(heal))
delay = 3.0
first = 1
targetTrack = Sequence()
for target in targets:
targetToon = target["toon"]
hp = target["hp"]
reactIval = Func(__healToon, targetToon, hp, ineffective, hasInteractivePropHealBonus)
if first:
targetTrack.append(Wait(delay))
first = 0
targetTrack.append(reactIval)
hat = globalPropPool.getProp("hat")
hat2 = MovieUtil.copyProp(hat)
hats = [hat, hat2]
cane = globalPropPool.getProp("cane")
cane2 = MovieUtil.copyProp(cane)
canes = [cane, cane2]
leftHands = toon.getLeftHands()
rightHands = toon.getRightHands()
dScale = 0.5
propTrack = Sequence(
Func(MovieUtil.showProps, hats, rightHands, Point3(0.23, 0.09, 0.69), Point3(180, 0, 0)),
Func(MovieUtil.showProps, canes, leftHands, Point3(-0.28, 0.0, 0.14), Point3(0.0, 0.0, -150.0)),
MovieUtil.getScaleIntervals(hats + canes, dScale, MovieUtil.PNT3_NEARZERO, MovieUtil.PNT3_ONE),
Wait(toon.getDuration("happy-dance") - 2.0 * dScale),
MovieUtil.getScaleIntervals(hats + canes, dScale, MovieUtil.PNT3_ONE, MovieUtil.PNT3_NEARZERO),
Func(MovieUtil.removeProps, hats + canes),
)
mtrack = Parallel(
propTrack, ActorInterval(toon, "happy-dance"), __getSoundTrack(level, 0.2, duration=6.4, node=toon), targetTrack
)
track.append(Func(toon.loop, "neutral"))
track.append(Wait(0.1))
track.append(mtrack)
if npcId != 0:
track.append(MovieNPCSOS.teleportOut(heal, toon))
else:
track.append(__returnToBase(heal))
for target in targets:
targetToon = target["toon"]
track.append(Func(targetToon.clearChat))
return track
def __doFoghorn(sound, delay, toon, targets, level):
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(0.10000000000000001, 0.10000000000000001, 0.10000000000000001)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(0.29999999999999999, 0.29999999999999999, 0.29999999999999999)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.40000000000000002, 0.40000000000000002, 0.40000000000000002)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [
megaphone,
megaphone2]
instrument = globalPropPool.getProp('fog_horn')
instrument2 = MovieUtil.copyProp(instrument)
instruments = [
instrument,
instrument2]
def setInstrumentStats(instrument = instrument, instrument2 = instrument2):
instrument.setPos(-0.80000000000000004, -0.90000000000000002, 0.20000000000000001)
instrument.setHpr(145, 0, 0)
instrument.setScale(instrMin)
instrument2.setPos(-0.80000000000000004, -0.90000000000000002, 0.20000000000000001)
instrument2.setHpr(145, 0, 0)
instrument2.setScale(instrMin)
hands = toon.getRightHands()
megaphoneShow = Sequence(Func(MovieUtil.showProps, megaphones, hands), Func(MovieUtil.showProps, instruments, hands), Func(setInstrumentStats))
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones), Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(appearSoundFiles[level])
grow1 = getScaleIntervals(instruments, duration = 1, startScale = instrMin, endScale = instrMax1)
grow2 = getScaleIntervals(instruments, duration = 0.10000000000000001, startScale = instrMax1, endScale = instrMax2)
instrumentAppear = Parallel(Sequence(grow1, grow2), Sequence(Wait(0.050000000000000003), SoundInterval(instrumentAppearSfx, node = toon)))
stretchInstr = getScaleBlendIntervals(instruments, duration = 0.29999999999999999, startScale = instrMax2, endScale = instrStretch, blendType = 'easeOut')
backInstr = getScaleBlendIntervals(instruments, duration = 1.0, startScale = instrStretch, endScale = instrMin, blendType = 'easeIn')
spinInstr1 = LerpHprInterval(instrument, duration = 1.5, startHpr = Vec3(145, 0, 0), hpr = Vec3(145, 0, 90), blendType = 'easeInOut')
spinInstr2 = LerpHprInterval(instrument2, duration = 1.5, startHpr = Vec3(145, 0, 0), hpr = Vec3(145, 0, 90), blendType = 'easeInOut')
spinInstr = Parallel(spinInstr1, spinInstr2)
attackTrack = Parallel(Sequence(Wait(0.20000000000000001), spinInstr), Sequence(stretchInstr, Wait(0.5), backInstr))
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
megaphoneTrack = Sequence(Wait(delayTime), megaphoneShow, Wait(1.0), instrumentAppear, Wait(3.0), megaphoneHide)
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound, delay, toon)
tracks.append(toonTrack)
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
if soundEffect:
delayTime = delay + tSound
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Sequence(Wait(delayTime), Parallel(attackTrack, SoundInterval(soundEffect, node = toon)))
tracks.append(soundTrack)
return tracks
def __doBugle(sound, delay, toon, targets, level):
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax = Vec3(0.4, 0.4, 0.4)
instrMax *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.5, 0.5, 0.5)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
instrument = globalPropPool.getProp('bugle')
instrument2 = MovieUtil.copyProp(instrument)
instruments = [instrument, instrument2]
def setInstrumentStats(instrument = instrument, instrument2 = instrument2):
instrument.setPos(-1.3, -1.4, 0.1)
instrument.setHpr(145, 0, 85)
instrument.setScale(instrMin)
instrument2.setPos(-1.3, -1.4, 0.1)
instrument2.setHpr(145, 0, 85)
instrument2.setScale(instrMin)
def longshake(models, num):
inShake = getScaleBlendIntervals(models, duration=0.2, startScale=instrMax, endScale=instrStretch, blendType='easeInOut')
outShake = getScaleBlendIntervals(models, duration=0.2, startScale=instrStretch, endScale=instrMax, blendType='easeInOut')
i = 1
seq = Sequence()
while i < num:
if i % 2 == 0:
seq.append(inShake)
else:
seq.append(outShake)
i += 1
seq.start()
hands = toon.getRightHands()
megaphoneShow = Sequence(Func(MovieUtil.showProps, megaphones, hands), Func(MovieUtil.showProps, instruments, hands), Func(setInstrumentStats))
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones), Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(appearSoundFiles[level])
grow = getScaleBlendIntervals(instruments, duration=1, startScale=instrMin, endScale=instrMax, blendType='easeInOut')
instrumentshrink = getScaleIntervals(instruments, duration=0.1, startScale=instrMax, endScale=instrMin)
instrumentAppear = Sequence(grow, Wait(0), Func(longshake, instruments, 5))
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
megaphoneTrack = Parallel(Sequence(Wait(delay + 1.7), SoundInterval(soundEffect, node=toon)), Sequence(Wait(delayTime), megaphoneShow, Wait(1.7), instrumentAppear, Wait(1), instrumentshrink, Wait(1.5), megaphoneHide))
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound, delay, toon)
tracks.append(toonTrack)
if soundEffect:
delayTime = delay + tSound
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Wait(delayTime)
tracks.append(soundTrack)
return tracks
def __doSmooch(attack, hp=0):
toon = NPCToons.createLocalNPC(attack["npcId"])
if toon == None:
return
targets = attack["toons"]
level = 2
battle = attack["battle"]
track = Sequence(teleportIn(attack, toon))
lipstick = globalPropPool.getProp("lipstick")
lipstick2 = MovieUtil.copyProp(lipstick)
lipsticks = [lipstick, lipstick2]
rightHands = toon.getRightHands()
dScale = 0.5
lipstickTrack = Sequence(
Func(MovieUtil.showProps, lipsticks, rightHands, Point3(-0.27, -0.24, -0.95), Point3(-118, -10.6, -25.9)),
MovieUtil.getScaleIntervals(lipsticks, dScale, MovieUtil.PNT3_NEARZERO, MovieUtil.PNT3_ONE),
Wait(toon.getDuration("smooch") - 2.0 * dScale),
MovieUtil.getScaleIntervals(lipsticks, dScale, MovieUtil.PNT3_ONE, MovieUtil.PNT3_NEARZERO),
)
lips = globalPropPool.getProp("lips")
dScale = 0.5
tLips = 2.5
tThrow = 115.0 / toon.getFrameRate("smooch")
dThrow = 0.5
def getLipPos(toon=toon):
toon.pose("smooch", 57)
toon.update(0)
hand = toon.getRightHands()[0]
return hand.getPos(render)
effectTrack = Sequence()
for target in targets:
lipcopy = MovieUtil.copyProp(lips)
lipsTrack = Sequence(
Wait(tLips),
Func(MovieUtil.showProp, lipcopy, render, getLipPos),
Func(lipcopy.setBillboardPointWorld),
LerpScaleInterval(lipcopy, dScale, Point3(3, 3, 3), startScale=MovieUtil.PNT3_NEARZERO),
Wait(tThrow - tLips - dScale),
LerpPosInterval(lipcopy, dThrow, Point3(target.getPos() + Point3(0, 0, target.getHeight()))),
Func(MovieUtil.removeProp, lipcopy),
)
delay = tThrow + dThrow
mtrack = Parallel(
lipstickTrack,
lipsTrack,
__getSoundTrack(level, 2, node=toon),
Sequence(ActorInterval(toon, "smooch")),
Sequence(Wait(delay), ActorInterval(target, "conked")),
Sequence(Wait(delay), Func(__healToon, target, hp)),
)
effectTrack.append(mtrack)
effectTrack.append(Func(MovieUtil.removeProps, lipsticks))
track.append(effectTrack)
track.append(teleportOut(attack, toon))
track.append(Func(target.clearChat))
return track
def __doAoogah(sound, delay, toon, targets, level):
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax = Vec3(0.5, 0.5, 0.5)
instrMax *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(1.1, 0.9, 0.4)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp("megaphone")
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
instrument = globalPropPool.getProp("aoogah")
instrument2 = MovieUtil.copyProp(instrument)
instruments = [instrument, instrument2]
def setInstrumentStats(instrument=instrument, instrument2=instrument2):
instrument.setPos(-1.0, -1.5, 0.2)
instrument.setHpr(145, 0, 85)
instrument.setScale(instrMin)
instrument2.setPos(-1.0, -1.5, 0.2)
instrument2.setHpr(145, 0, 85)
instrument2.setScale(instrMin)
hands = toon.getRightHands()
megaphoneShow = Sequence(
Func(MovieUtil.showProps, megaphones, hands),
Func(MovieUtil.showProps, instruments, hands),
Func(setInstrumentStats),
)
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones), Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(appearSoundFiles[level])
grow = getScaleIntervals(instruments, duration=0.2, startScale=instrMin, endScale=instrMax)
instrumentAppear = Parallel(grow, Sequence(Wait(0.05), SoundInterval(instrumentAppearSfx, node=toon)))
stretchInstr = getScaleBlendIntervals(
instruments, duration=0.2, startScale=instrMax, endScale=instrStretch, blendType="easeOut"
)
backInstr = getScaleBlendIntervals(
instruments, duration=0.2, startScale=instrStretch, endScale=instrMax, blendType="easeInOut"
)
attackTrack = Sequence(stretchInstr, Wait(1), backInstr)
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
megaphoneTrack = Sequence(Wait(delayTime), megaphoneShow, Wait(1.0), instrumentAppear, Wait(3.0), megaphoneHide)
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound, delay, toon)
tracks.append(toonTrack)
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
instrumentshrink = getScaleIntervals(instruments, duration=0.1, startScale=instrMax, endScale=instrMin)
if soundEffect:
delayTime = delay + tSound
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Sequence(
Wait(delayTime),
Parallel(attackTrack, SoundInterval(soundEffect, node=toon), Sequence(Wait(1.5), instrumentshrink)),
)
tracks.append(soundTrack)
return tracks
def __healDance(heal, hasInteractivePropHealBonus):
npcId = 0
if heal.has_key('npcId'):
npcId = heal['npcId']
toon = NPCToons.createLocalNPC(npcId)
if toon == None:
return None
else:
toon = heal['toon']
targets = heal['target']
ineffective = heal['sidestep']
level = heal['level']
if npcId != 0:
track = Sequence(MovieNPCSOS.teleportIn(heal, toon))
else:
track = Sequence(__runToHealSpot(heal))
delay = 3.0
first = 1
targetTrack = Sequence()
for target in targets:
targetToon = target['toon']
hp = target['hp']
reactIval = Func(__healToon, targetToon, hp, ineffective, hasInteractivePropHealBonus)
if first:
targetTrack.append(Wait(delay))
first = 0
targetTrack.append(reactIval)
hat = globalPropPool.getProp('hat')
hat2 = MovieUtil.copyProp(hat)
hats = [
hat,
hat2]
cane = globalPropPool.getProp('cane')
cane2 = MovieUtil.copyProp(cane)
canes = [
cane,
cane2]
leftHands = toon.getLeftHands()
rightHands = toon.getRightHands()
dScale = 0.5
propTrack = Sequence(Func(MovieUtil.showProps, hats, rightHands, Point3(0.23000000000000001, 0.089999999999999997, 0.68999999999999995), Point3(180, 0, 0)), Func(MovieUtil.showProps, canes, leftHands, Point3(-0.28000000000000003, 0.0, 0.14000000000000001), Point3(0.0, 0.0, -150.0)), MovieUtil.getScaleIntervals(hats + canes, dScale, MovieUtil.PNT3_NEARZERO, MovieUtil.PNT3_ONE), Wait(toon.getDuration('happy-dance') - 2.0 * dScale), MovieUtil.getScaleIntervals(hats + canes, dScale, MovieUtil.PNT3_ONE, MovieUtil.PNT3_NEARZERO), Func(MovieUtil.removeProps, hats + canes))
mtrack = Parallel(propTrack, ActorInterval(toon, 'happy-dance'), __getSoundTrack(level, 0.20000000000000001, duration = 6.4000000000000004, node = toon), targetTrack)
track.append(Func(toon.loop, 'neutral'))
track.append(Wait(0.10000000000000001))
track.append(mtrack)
if npcId != 0:
track.append(MovieNPCSOS.teleportOut(heal, toon))
else:
track.append(__returnToBase(heal))
for target in targets:
targetToon = target['toon']
track.append(Func(targetToon.clearChat))
return track
def __doOpera(sound, delay, toon, targets, level):
tracks = Parallel()
delay = delay
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(1.7, 1.7, 1.7)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(2.2, 2.2, 2.2)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.4, 0.4, 0.4)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
instrument = globalPropPool.getProp('singing')
instrument2 = MovieUtil.copyProp(instrument)
instruments = [instrument, instrument2]
head = instrument2.find('**/opera_singer')
head.setPos(0, 0, 0)
def setInstrumentStats(instrument = instrument, instrument2 = instrument2):
notify.debug('setInstrumentStats')
newPos = Vec3(-0.8, -0.9, 0.2)
newPos *= 1.3
instrument.setPos(newPos[0], newPos[1], newPos[2])
instrument.setHpr(145, 0, 90)
instrument.setScale(instrMin)
instrument2.setPos(newPos[0], newPos[1], newPos[2])
instrument2.setHpr(145, 0, 90)
instrument2.setScale(instrMin)
hands = toon.getRightHands()
megaphoneShow = Sequence(Func(MovieUtil.showProps, megaphones, hands), Func(MovieUtil.showProps, instruments, hands), Func(setInstrumentStats))
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones), Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(appearSoundFiles[level])
grow1 = getScaleBlendIntervals(instruments, duration=1, startScale=instrMin, endScale=instrMax1, blendType='easeOut')
grow2 = getScaleBlendIntervals(instruments, duration=1.1, startScale=instrMax1, endScale=instrMax2, blendType='easeIn')
shrink2 = getScaleIntervals(instruments, duration=0.1, startScale=instrMax2, endScale=instrMin)
instrumentAppear = Parallel(Sequence(grow1, grow2, Wait(6.0), shrink2), Sequence(Wait(0.0), SoundInterval(instrumentAppearSfx, node=toon)))
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
megaphoneTrack = Sequence(Wait(delayTime), megaphoneShow, Wait(1.0), instrumentAppear, Wait(2.0), megaphoneHide)
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound, delay, toon, operaInstrument=instrument)
tracks.append(toonTrack)
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
if soundEffect:
delayTime = delay + tSound - 0.3
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Sequence(Wait(delayTime), SoundInterval(soundEffect, node=toon))
tracks.append(Sequence(Wait(0)))
tracks.append(soundTrack)
return tracks
def __doElephant(sound, delay, toon, targets, level):
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(0.3, 0.4, 0.2)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(0.3, 0.3, 0.3)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch1 = Vec3(0.3, 0.5, 0.25)
instrStretch1 *= INSTRUMENT_SCALE_MODIFIER
instrStretch2 = Vec3(0.3, 0.7, 0.3)
instrStretch2 *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
instrument = globalPropPool.getProp('elephant')
instrument2 = MovieUtil.copyProp(instrument)
instruments = [instrument, instrument2]
def setInstrumentStats(instrument = instrument, instrument2 = instrument2):
instrument.setPos(-.6, -.9, 0.15)
instrument.setHpr(145, 0, 85)
instrument.setScale(instrMin)
instrument2.setPos(-.6, -.9, 0.15)
instrument2.setHpr(145, 0, 85)
instrument2.setScale(instrMin)
hands = toon.getRightHands()
megaphoneShow = Sequence(Func(MovieUtil.showProps, megaphones, hands), Func(MovieUtil.showProps, instruments, hands), Func(setInstrumentStats))
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones), Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(appearSoundFiles[level])
grow1 = getScaleIntervals(instruments, duration=0.3, startScale=instrMin, endScale=instrMax1)
grow2 = getScaleIntervals(instruments, duration=0.3, startScale=instrMax1, endScale=instrMax2)
instrumentAppear = Parallel(Sequence(grow1, grow2), Sequence(Wait(0.05), SoundInterval(instrumentAppearSfx, node=toon)))
stretchInstr1 = getScaleBlendIntervals(instruments, duration=0.1, startScale=instrMax2, endScale=instrStretch1, blendType='easeOut')
stretchInstr2 = getScaleBlendIntervals(instruments, duration=0.1, startScale=instrStretch1, endScale=instrStretch2, blendType='easeOut')
stretchInstr = Sequence(stretchInstr1, stretchInstr2)
backInstr = getScaleBlendIntervals(instruments, duration=0.1, startScale=instrStretch2, endScale=instrMax2, blendType='easeOut')
attackTrack = Sequence(stretchInstr, Wait(1), backInstr)
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
megaphoneTrack = Sequence(Wait(delayTime), megaphoneShow, Wait(1.0), instrumentAppear, Wait(3.0), megaphoneHide)
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound, delay, toon)
tracks.append(toonTrack)
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
instrumentshrink = getScaleIntervals(instruments, duration=0.1, startScale=instrMax2, endScale=instrMin)
if soundEffect:
delayTime = delay + tSound
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Sequence(Wait(delayTime), Parallel(attackTrack, SoundInterval(soundEffect, node=toon), Sequence(Wait(1.5), instrumentshrink)))
tracks.append(soundTrack)
return tracks
def __healTickle(heal, hasInteractivePropHealBonus):
toon = heal["toon"]
target = heal["target"]["toon"]
hp = heal["target"]["hp"]
ineffective = heal["sidestep"]
level = heal["level"]
track = Sequence(__runToHealSpot(heal))
feather = globalPropPool.getProp("feather")
feather2 = MovieUtil.copyProp(feather)
feathers = [feather, feather2]
hands = toon.getRightHands()
def scaleFeathers(feathers, toon=toon, target=target):
toon.pose("tickle", 63)
toon.update(0)
hand = toon.getRightHands()[0]
horizDistance = Vec3(hand.getPos(render) - target.getPos(render))
horizDistance.setZ(0)
distance = horizDistance.length()
if target.style.torso[0] == "s":
distance -= 0.5
else:
distance -= 0.3
featherLen = 2.4
scale = distance / (featherLen * hand.getScale(render)[0])
for feather in feathers:
feather.setScale(scale)
tFeatherScaleUp = 0.5
dFeatherScaleUp = 0.5
dFeatherScaleDown = 0.5
featherTrack = Parallel(
MovieUtil.getActorIntervals(feathers, "feather"),
Sequence(
Wait(tFeatherScaleUp),
Func(MovieUtil.showProps, feathers, hands),
Func(scaleFeathers, feathers),
MovieUtil.getScaleIntervals(feathers, dFeatherScaleUp, MovieUtil.PNT3_NEARZERO, feathers[0].getScale),
),
Sequence(
Wait(toon.getDuration("tickle") - dFeatherScaleDown),
MovieUtil.getScaleIntervals(feathers, dFeatherScaleDown, None, MovieUtil.PNT3_NEARZERO),
),
)
tHeal = 3.0
mtrack = Parallel(
featherTrack,
ActorInterval(toon, "tickle"),
__getSoundTrack(level, 1, node=toon),
Sequence(
Wait(tHeal),
Func(__healToon, target, hp, ineffective, hasInteractivePropHealBonus),
ActorInterval(target, "cringe", startTime=20.0 / target.getFrameRate("cringe")),
),
)
track.append(mtrack)
track.append(Func(MovieUtil.removeProps, feathers))
track.append(__returnToBase(heal))
track.append(Func(target.clearChat))
return track
def __healJuggle(heal, hasInteractivePropHealBonus):
npcId = 0
if 'npcId' in heal:
npcId = heal['npcId']
toon = NPCToons.createLocalNPC(npcId)
if toon is None:
return
else:
toon = heal['toon']
targets = heal['target']
ineffective = heal['sidestep']
level = heal['level']
if npcId != 0:
track = Sequence(MovieNPCSOS.teleportIn(heal, toon))
else:
track = Sequence(__runToHealSpot(heal))
delay = 4.0
first = 1
targetTrack = Sequence()
for target in targets:
targetToon = target['toon']
hp = target['hp']
reactIval = Func(
__healToon,
targetToon,
hp,
ineffective,
hasInteractivePropHealBonus)
if first == 1:
targetTrack.append(Wait(delay))
first = 0
targetTrack.append(reactIval)
cube = globalPropPool.getProp('cubes')
cube2 = MovieUtil.copyProp(cube)
cubes = [cube, cube2]
hips = [
toon.getLOD(
toon.getLODNames()[0]).find('**/joint_hips'),
toon.getLOD(
toon.getLODNames()[1]).find('**/joint_hips')]
cubeTrack = Sequence(
Func(
MovieUtil.showProps, cubes, hips), MovieUtil.getActorIntervals(
cubes, 'cubes'), Func(
MovieUtil.removeProps, cubes))
mtrack = Parallel(
cubeTrack, __getSoundTrack(
level, 0.7, duration=7.7, node=toon), ActorInterval(
toon, 'juggle'), targetTrack)
track.append(mtrack)
if npcId != 0:
track.append(MovieNPCSOS.teleportOut(heal, toon))
else:
track.append(__returnToBase(heal))
for target in targets:
targetToon = target['toon']
track.append(Func(targetToon.clearChat))
return track
def __healSmooch(heal, hasInteractivePropHealBonus):
toon = heal['toon']
target = heal['target']['toon']
level = heal['level']
hp = heal['target']['hp']
ineffective = heal['sidestep']
track = Sequence(__runToHealSpot(heal))
lipstick = globalPropPool.getProp('lipstick')
lipstick2 = MovieUtil.copyProp(lipstick)
lipsticks = [
lipstick,
lipstick2]
rightHands = toon.getRightHands()
dScale = 0.5
lipstickTrack = Sequence(Func(MovieUtil.showProps, lipsticks, rightHands, Point3(-0.27000000000000002, -0.23999999999999999, -0.94999999999999996), Point3(-118, -10.6, -25.899999999999999)), MovieUtil.getScaleIntervals(lipsticks, dScale, MovieUtil.PNT3_NEARZERO, MovieUtil.PNT3_ONE), Wait(toon.getDuration('smooch') - 2.0 * dScale), MovieUtil.getScaleIntervals(lipsticks, dScale, MovieUtil.PNT3_ONE, MovieUtil.PNT3_NEARZERO), Func(MovieUtil.removeProps, lipsticks))
lips = globalPropPool.getProp('lips')
dScale = 0.5
tLips = 2.5
tThrow = 115.0 / toon.getFrameRate('smooch')
dThrow = 0.5
def getLipPos(toon = toon):
toon.pose('smooch', 57)
toon.update(0)
hand = toon.getRightHands()[0]
return hand.getPos(render)
lipsTrack = Sequence(Wait(tLips), Func(MovieUtil.showProp, lips, render, getLipPos), Func(lips.setBillboardPointWorld), LerpScaleInterval(lips, dScale, Point3(3, 3, 3), startScale = MovieUtil.PNT3_NEARZERO), Wait(tThrow - tLips - dScale), LerpPosInterval(lips, dThrow, Point3(target.getPos() + Point3(0, 0, target.getHeight()))), Func(MovieUtil.removeProp, lips))
delay = tThrow + dThrow
mtrack = Parallel(lipstickTrack, lipsTrack, __getSoundTrack(level, 2, node = toon), Sequence(ActorInterval(toon, 'smooch'), *__returnToBase(heal)), Sequence(Wait(delay), ActorInterval(target, 'conked')), Sequence(Wait(delay), Func(__healToon, target, hp, ineffective, hasInteractivePropHealBonus)))
track.append(mtrack)
track.append(Func(target.clearChat))
return track
def __createMagnetMultiTrack(lure, magnet, pos, hpr, scale, isSmallMagnet = 1, npcs = []):
toon = lure['toon']
if 'npc' in lure:
toon = lure['npc']
battle = lure['battle']
sidestep = lure['sidestep']
targets = lure['target']
tracks = Parallel()
tracks.append(Sequence(ActorInterval(toon, 'hold-magnet'), Func(toon.loop, 'neutral')))
hands = toon.getLeftHands()
magnet2 = MovieUtil.copyProp(magnet)
magnets = [magnet, magnet2]
magnetTrack = Sequence(Wait(0.7), Func(MovieUtil.showProps, magnets, hands, pos, hpr, scale), Wait(6.3), Func(MovieUtil.removeProps, magnets))
tracks.append(magnetTrack)
for target in targets:
suit = target['suit']
trapProp = suit.battleTrapProp
if sidestep == 0:
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
if kbbonus == 1 or hp > 0:
suitDelay = 2.6
suitMoveDuration = 0.8
suitTrack = Sequence()
opos, ohpr = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
numShakes = 3
shakeTotalDuration = 0.8
shakeDuration = shakeTotalDuration / float(numShakes)
suitTrack.append(Func(suit.loop, 'neutral'))
suitTrack.append(Wait(suitDelay))
suitTrack.append(ActorInterval(suit, 'landing', startTime=2.37, endTime=1.82))
for i in xrange(0, numShakes):
suitTrack.append(ActorInterval(suit, 'landing', startTime=1.82, endTime=1.16, duration=shakeDuration))
suitTrack.append(ActorInterval(suit, 'landing', startTime=1.16, endTime=0.7))
suitTrack.append(ActorInterval(suit, 'landing', startTime=0.7, duration=1.3))
suitTrack.append(Func(suit.loop, 'lured'))
suitTrack.append(Func(battle.lureSuit, suit))
if hp > 0:
suitTrack.append(__createSuitDamageTrack(battle, suit, hp, lure, trapProp))
if revived != 0:
suitTrack.append(MovieUtil.createSuitReviveTrack(suit, toon, battle, npcs))
elif died != 0:
if not (trapProp.getName() == 'tnt' and suit.maxHP <= 42):
suitTrack.append(MovieUtil.createSuitDeathTrack(suit, toon, battle, npcs))
tracks.append(suitTrack)
tracks.append(lerpSuit(suit, suitDelay + 0.55 + shakeTotalDuration, suitMoveDuration, reachPos, battle, trapProp))
else:
tracks.append(Sequence(Wait(3.7), Func(MovieUtil.indicateMissed, suit)))
if isSmallMagnet == 1:
tracks.append(getSoundTrack('TL_small_magnet.ogg', delay=0.7, node=toon))
else:
tracks.append(getSoundTrack('TL_large_magnet.ogg', delay=0.7, node=toon))
return tracks
def __healJoke(heal, hasInteractivePropHealBonus):
npcId = 0
if heal.has_key('npcId'):
npcId = heal['npcId']
toon = NPCToons.createLocalNPC(npcId)
if toon == None:
return None
else:
toon = heal['toon']
targets = heal['target']
ineffective = heal['sidestep']
level = heal['level']
jokeIndex = heal['hpbonus'] % len(HealJokes.toonHealJokes)
if npcId != 0:
track = Sequence(MovieNPCSOS.teleportIn(heal, toon))
else:
track = Sequence(__runToHealSpot(heal))
tracks = Parallel()
fSpeakPunchline = 58
tSpeakSetup = 0.0
tSpeakPunchline = 3.0
dPunchLine = 3.0
tTargetReact = tSpeakPunchline + 1.0
dTargetLaugh = 1.5
tRunBack = tSpeakPunchline + dPunchLine
tDoSoundAnimation = tSpeakPunchline - float(fSpeakPunchline) / toon.getFrameRate('sound')
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [
megaphone,
megaphone2]
hands = toon.getRightHands()
dMegaphoneScale = 0.5
tracks.append(Sequence(Wait(tDoSoundAnimation), Func(MovieUtil.showProps, megaphones, hands), MovieUtil.getScaleIntervals(megaphones, dMegaphoneScale, MovieUtil.PNT3_NEARZERO, MovieUtil.PNT3_ONE), Wait(toon.getDuration('sound') - 2.0 * dMegaphoneScale), MovieUtil.getScaleIntervals(megaphones, dMegaphoneScale, MovieUtil.PNT3_ONE, MovieUtil.PNT3_NEARZERO), Func(MovieUtil.removeProps, megaphones)))
tracks.append(Sequence(Wait(tDoSoundAnimation), ActorInterval(toon, 'sound')))
soundTrack = __getSoundTrack(level, 2.0, node = toon)
tracks.append(soundTrack)
joke = HealJokes.toonHealJokes[jokeIndex]
tracks.append(Sequence(Wait(tSpeakSetup), Func(toon.setChatAbsolute, joke[0], CFSpeech | CFTimeout)))
tracks.append(Sequence(Wait(tSpeakPunchline), Func(toon.setChatAbsolute, joke[1], CFSpeech | CFTimeout)))
reactTrack = Sequence(Wait(tTargetReact))
for target in targets:
targetToon = target['toon']
hp = target['hp']
reactTrack.append(Func(__healToon, targetToon, hp, ineffective, hasInteractivePropHealBonus))
reactTrack.append(Wait(dTargetLaugh))
for target in targets:
targetToon = target['toon']
reactTrack.append(Func(targetToon.clearChat))
tracks.append(reactTrack)
if npcId != 0:
track.append(Sequence(Wait(tRunBack), Func(toon.clearChat), *MovieNPCSOS.teleportOut(heal, toon)))
else:
tracks.append(Sequence(Wait(tRunBack), Func(toon.clearChat), *__returnToBase(heal)))
track.append(tracks)
return track
def __createHypnoGogglesMultiTrack(lure, npcs = []):
toon = lure['toon']
if lure.has_key('npc'):
toon = lure['npc']
targets = lure['target']
battle = lure['battle']
sidestep = lure['sidestep']
goggles = globalPropPool.getProp('hypno-goggles')
goggles2 = MovieUtil.copyProp(goggles)
bothGoggles = [
goggles,
goggles2]
pos = Point3(-1.03, 1.04, -0.29999999999999999)
hpr = Point3(-96.549999999999997, 36.140000000000001, -170.59)
scale = Point3(1.5, 1.5, 1.5)
hands = toon.getLeftHands()
gogglesTrack = Sequence(Wait(0.59999999999999998), Func(MovieUtil.showProps, bothGoggles, hands, pos, hpr, scale), ActorInterval(goggles, 'hypno-goggles', duration = 2.2000000000000002), Func(MovieUtil.removeProps, bothGoggles))
toonTrack = Sequence(ActorInterval(toon, 'hypnotize'), Func(toon.loop, 'neutral'))
tracks = Parallel(gogglesTrack, toonTrack)
for target in targets:
suit = target['suit']
trapProp = suit.battleTrapProp
if sidestep == 0:
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
if kbbonus == 1 or hp > 0:
suitTrack = Sequence()
suitDelay = 1.6000000000000001
suitAnimDuration = 1.5
(opos, ohpr) = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
suitTrack.append(Func(suit.loop, 'neutral'))
suitTrack.append(Wait(suitDelay))
suitTrack.append(ActorInterval(suit, 'hypnotized', duration = 3.1000000000000001))
suitTrack.append(Func(suit.setPos, battle, reachPos))
suitTrack.append(Func(suit.loop, 'neutral'))
suitTrack.append(Func(battle.lureSuit, suit))
if hp > 0:
suitTrack.append(__createSuitDamageTrack(battle, suit, hp, lure, trapProp))
if revived != 0:
suitTrack.append(MovieUtil.createSuitReviveTrack(suit, toon, battle, npcs))
elif died != 0:
suitTrack.append(MovieUtil.createSuitDeathTrack(suit, toon, battle, npcs))
tracks.append(suitTrack)
tracks.append(lerpSuit(suit, suitDelay + 1.7, 0.69999999999999996, reachPos, battle, trapProp))
hp > 0
tracks.append(Sequence(Wait(2.2999999999999998), Func(MovieUtil.indicateMissed, suit, 1.1000000000000001)))
tracks.append(getSoundTrack('TL_hypnotize.mp3', delay = 0.5, node = toon))
return tracks
def getGeyserTrack(geyser, suit, geyserPosPoint, scaleUpPoint, rainEffects, rainDelay, effectDelay, geyserHold, useEffect, battle = battle):
geyserMound = MovieUtil.copyProp(geyser)
geyserRemoveM = geyserMound.findAllMatches('**/Splash*')
geyserRemoveM.addPathsFrom(geyserMound.findAllMatches('**/spout'))
for i in range(geyserRemoveM.getNumPaths()):
geyserRemoveM[i].removeNode()
geyserWater = MovieUtil.copyProp(geyser)
geyserRemoveW = geyserWater.findAllMatches('**/hole')
geyserRemoveW.addPathsFrom(geyserWater.findAllMatches('**/shadow'))
for i in range(geyserRemoveW.getNumPaths()):
geyserRemoveW[i].removeNode()
track = Sequence(Wait(rainDelay), Func(MovieUtil.showProp, geyserMound, battle, suit.getPos(battle)), Func(MovieUtil.showProp, geyserWater, battle, suit.getPos(battle)), LerpScaleInterval(geyserWater, 1.0, scaleUpPoint, startScale=MovieUtil.PNT3_NEARZERO), Wait(geyserHold * 0.5), LerpScaleInterval(geyserWater, 0.5, MovieUtil.PNT3_NEARZERO, startScale=scaleUpPoint))
track.append(LerpScaleInterval(geyserMound, 0.5, MovieUtil.PNT3_NEARZERO))
track.append(Func(MovieUtil.removeProp, geyserMound))
track.append(Func(MovieUtil.removeProp, geyserWater))
track.append(Func(MovieUtil.removeProp, geyser))
return track
def __healJuggle(heal):
toon = heal['toon']
targets = heal['target']
ineffective = heal['sidestep']
level = heal['level']
ivals = __runToHealSpot(heal)
delay = 4.0
first = 1
targetIvals = []
for target in targets:
targetToon = target['toon']
hp = target['hp']
reactIval = FunctionInterval(__healToon, extraArgs = [
targetToon,
hp,
ineffective])
if first == 1:
targetIvals.append((delay, reactIval, PREVIOUS_END))
first = 0
else:
targetIvals.append(reactIval)
cube = globalPropPool.getProp('cubes')
cube2 = MovieUtil.copyProp(cube)
cubes = [
cube,
cube2]
hips = [
toon.getLOD(toon.getLODNames()[0]).find('**/joint-hips'),
toon.getLOD(toon.getLODNames()[1]).find('**/joint-hips')]
cubeIvals = [
FunctionInterval(MovieUtil.showProps, extraArgs = [
cubes,
hips]),
MovieUtil.getActorIntervals(cubes, 'cubes'),
FunctionInterval(MovieUtil.removeProps, extraArgs = [
cubes])]
mtrack = MultiTrack([
Track(cubeIvals),
__getSoundTrack(level, 0.69999999999999996, duration = 7.7000000000000002, node = toon),
Track([
ActorInterval(toon, 'juggle')]),
Track(targetIvals)])
ivals.append(mtrack)
ivals += __returnToBase(heal)
for target in targets:
targetToon = target['toon']
ivals.append(FunctionInterval(targetToon.clearChat))
return Track(ivals)
def __createThrownTrapMultiTrack(
trap,
propList,
propName,
propPos=None,
propHpr=None,
anim=0,
explode=0):
toon = trap['toon']
level = trap['level']
battle = trap['battle']
target = trap['target']
suit = target[0]['suit']
targetPos = suit.getPos(battle)
thrownProp = propList[0]
unthrownProp = propList[1]
torso = toon.style.torso
torso = torso[0]
if torso == 'l':
throwDelay = 2.3
elif torso == 'm':
throwDelay = 2.3
else:
throwDelay = 1.9
throwDuration = 0.9
animBreakPoint = throwDelay + throwDuration
animDelay = 3.1
trapTrack = ToontownBattleGlobals.TRAP_TRACK
trapTrackNames = ToontownBattleGlobals.AvProps[trapTrack]
trapName = trapTrackNames[level]
hands = toon.getRightHands()
propTrack = Sequence()
if propPos and propHpr:
propTrack.append(
Func(
MovieUtil.showProps,
propList,
hands,
propPos,
propHpr))
else:
propTrack.append(Func(MovieUtil.showProps, propList, hands))
if anim == 1:
pTracks = Parallel()
for prop in propList:
pTracks.append(
ActorInterval(
prop,
propName,
duration=animBreakPoint))
propTrack.append(pTracks)
throwTrack = Sequence()
throwTrack.append(Wait(throwDelay))
throwTrack.append(Func(unthrownProp.reparentTo, hidden))
throwTrack.append(Func(toon.update))
if suit.battleTrap != NO_TRAP:
notify.debug(
'trapSuit() - trap: %d destroyed existing trap: %d' %
(level, suit.battleTrap))
battle.removeTrap(suit)
if trapName == 'rake':
trapProp = globalPropPool.getProp('rake-react')
else:
trapProp = MovieUtil.copyProp(thrownProp)
suit.battleTrapProp = trapProp
suit.battleTrap = level
suit.battleTrapIsFresh = 1
if trapName == 'banana':
trapPoint, trapHpr = battle.getActorPosHpr(suit)
trapPoint.setY(MovieUtil.SUIT_TRAP_DISTANCE)
slidePoint = Vec3(
trapPoint.getX(),
trapPoint.getY() - 2,
trapPoint.getZ())
throwingTrack = createThrowingTrack(
thrownProp, slidePoint, duration=0.9, parent=battle)
moveTrack = LerpPosInterval(
thrownProp, 0.8, pos=trapPoint, other=battle)
animTrack = ActorInterval(
thrownProp, propName, startTime=animBreakPoint)
slideTrack = Parallel(moveTrack, animTrack)
motionTrack = Sequence(throwingTrack, slideTrack)
hprTrack = LerpHprInterval(thrownProp, 1.7, hpr=Point3(0, 0, 0))
soundTrack = getSoundTrack('TL_banana.ogg', node=toon)
scaleTrack = LerpScaleInterval(
thrownProp, 1.7, scale=MovieUtil.PNT3_ONE)
throwTrack.append(Wait(0.25))
throwTrack.append(Func(thrownProp.wrtReparentTo, suit))
throwTrack.append(
Parallel(
motionTrack,
hprTrack,
scaleTrack,
soundTrack))
elif trapName == 'tnt':
trapPoint, trapHpr = battle.getActorPosHpr(suit)
trapPoint.setY(MovieUtil.SUIT_TRAP_TNT_DISTANCE - 5.03)
trapPoint.setZ(trapPoint.getZ() + 0.4)
throwingTrack = createThrowingTrack(
thrownProp, trapPoint, duration=throwDuration, parent=battle)
hprTrack = LerpHprInterval(thrownProp, 0.9, hpr=Point3(180, 90, 0))
scaleTrack = LerpScaleInterval(
thrownProp, 0.9, scale=MovieUtil.PNT3_ONE)
soundTrack = getSoundTrack(
'TL_dynamite.ogg',
delay=0.8,
duration=0.7,
node=suit)
throwTrack.append(
Parallel(
throwingTrack,
hprTrack,
scaleTrack,
soundTrack))
elif trapName == 'marbles':
trapPoint, trapHpr = battle.getActorPosHpr(suit)
trapPoint.setY(MovieUtil.SUIT_TRAP_MARBLES_DISTANCE)
flingDuration = 0.2
rollDuration = 1.0
throwDuration = flingDuration + rollDuration
landPoint = Point3(0, trapPoint.getY() + 2, trapPoint.getZ())
throwPoint = Point3(0, trapPoint.getY(), trapPoint.getZ())
moveTrack = Sequence(
Func(
thrownProp.wrtReparentTo, suit), Func(
thrownProp.setHpr, Point3(
94, 0, 0)), LerpPosInterval(
thrownProp, flingDuration, pos=landPoint, other=suit), LerpPosInterval(
thrownProp, rollDuration, pos=throwPoint, other=suit))
animTrack = ActorInterval(
thrownProp, propName, startTime=throwDelay + 0.9)
scaleTrack = LerpScaleInterval(
thrownProp, throwDuration, scale=MovieUtil.PNT3_ONE)
soundTrack = getSoundTrack('TL_marbles.ogg', delay=0.1, node=toon)
throwTrack.append(Wait(0.2))
throwTrack.append(
Parallel(
moveTrack,
animTrack,
scaleTrack,
soundTrack))
elif trapName == 'rake':
trapPoint, trapHpr = battle.getActorPosHpr(suit)
trapPoint.setY(MovieUtil.SUIT_TRAP_RAKE_DISTANCE)
throwDuration = 1.1
throwingTrack = createThrowingTrack(
thrownProp, trapPoint, duration=throwDuration, parent=suit)
hprTrack = LerpHprInterval(
thrownProp, throwDuration, hpr=VBase3(
63.43, -90.0, 63.43))
scaleTrack = LerpScaleInterval(
thrownProp, 0.9, scale=Point3(
0.7, 0.7, 0.7))
soundTrack = SoundInterval(globalBattleSoundCache.getSound(
'TL_rake_throw_only.ogg'), duration=1.1, node=suit)
throwTrack.append(Wait(0.2))
throwTrack.append(
Parallel(
throwingTrack,
hprTrack,
scaleTrack,
soundTrack))
else:
notify.warning(
'__createThrownTrapMultiTrack() - Incorrect trap: %s thrown from toon' %
trapName)
def placeTrap(trapProp, suit, battle=battle, trapName=trapName):
if not trapProp or trapProp.isEmpty():
return
trapProp.wrtReparentTo(suit)
trapProp.show()
if trapName == 'rake':
trapProp.setPos(0, MovieUtil.SUIT_TRAP_RAKE_DISTANCE, 0)
trapProp.setHpr(Point3(0, 270, 0))
trapProp.setScale(Point3(0.7, 0.7, 0.7))
rakeOffset = MovieUtil.getSuitRakeOffset(suit)
trapProp.setY(trapProp.getY() + rakeOffset)
elif trapName == 'banana':
trapProp.setHpr(0, 0, 0)
trapProp.setPos(0, MovieUtil.SUIT_TRAP_DISTANCE, -0.35)
trapProp.pose(trapName, trapProp.getNumFrames(trapName) - 1)
elif trapName == 'marbles':
trapProp.setHpr(Point3(94, 0, 0))
trapProp.setPos(0, MovieUtil.SUIT_TRAP_MARBLES_DISTANCE, 0)
trapProp.pose(trapName, trapProp.getNumFrames(trapName) - 1)
elif trapName == 'tnt':
trapProp.setHpr(0, 90, 0)
trapProp.setPos(0, MovieUtil.SUIT_TRAP_TNT_DISTANCE, 0.4)
else:
notify.warning(
'placeTrap() - Incorrect trap: %s placed on a suit' %
trapName)
dustNode = hidden.attachNewNode('DustNode')
def placeDustExplosion(
dustNode=dustNode,
thrownProp=thrownProp,
battle=battle):
dustNode.reparentTo(battle)
dustNode.setPos(thrownProp.getPos(battle))
if explode == 1:
throwTrack.append(Func(thrownProp.wrtReparentTo, hidden))
throwTrack.append(Func(placeDustExplosion))
throwTrack.append(
createCartoonExplosionTrack(
dustNode,
'dust',
explosionPoint=Point3(
0,
0,
0)))
throwTrack.append(Func(battle.removeTrap, suit))
else:
throwTrack.append(Func(placeTrap, trapProp, suit))
if trapName == 'tnt':
tip = trapProp.find('**/joint_attachEmitter')
sparks = BattleParticles.createParticleEffect(file='tnt')
trapProp.sparksEffect = sparks
throwTrack.append(Func(sparks.start, tip))
throwTrack.append(Func(MovieUtil.removeProps, propList))
toonTrack = Sequence(
Func(
toon.headsUp, battle, targetPos), ActorInterval(
toon, 'toss'), Func(
toon.loop, 'neutral'))
return Parallel(propTrack, throwTrack, toonTrack)
def __healDance(heal, hasInteractivePropHealBonus):
npcId = 0
if 'npcId' in heal:
npcId = heal['npcId']
toon = NPCToons.createLocalNPC(npcId)
if toon == None:
return
else:
toon = heal['toon']
targets = heal['target']
ineffective = heal['sidestep']
level = heal['level']
if npcId != 0:
track = Sequence(MovieNPCSOS.teleportIn(heal, toon))
else:
track = Sequence(__runToHealSpot(heal))
delay = 3.0
first = 1
targetTrack = Sequence()
for target in targets:
targetToon = target['toon']
hp = target['hp']
reactIval = Func(__healToon, targetToon, hp, ineffective,
hasInteractivePropHealBonus)
if first:
targetTrack.append(Wait(delay))
first = 0
targetTrack.append(reactIval)
hat = globalPropPool.getProp('hat')
hat2 = MovieUtil.copyProp(hat)
hats = [hat, hat2]
cane = globalPropPool.getProp('cane')
cane2 = MovieUtil.copyProp(cane)
canes = [cane, cane2]
leftHands = toon.getLeftHands()
rightHands = toon.getRightHands()
dScale = 0.5
propTrack = Sequence(
Func(MovieUtil.showProps, hats, rightHands, Point3(0.23, 0.09, 0.69),
Point3(180, 0, 0)),
Func(MovieUtil.showProps, canes, leftHands, Point3(-0.28, 0.0, 0.14),
Point3(0.0, 0.0, -150.0)),
MovieUtil.getScaleIntervals(hats + canes, dScale,
MovieUtil.PNT3_NEARZERO,
MovieUtil.PNT3_ONE),
Wait(toon.getDuration('happy-dance') - 2.0 * dScale),
MovieUtil.getScaleIntervals(hats + canes, dScale, MovieUtil.PNT3_ONE,
MovieUtil.PNT3_NEARZERO),
Func(MovieUtil.removeProps, hats + canes))
mtrack = Parallel(propTrack, ActorInterval(toon, 'happy-dance'),
__getSoundTrack(level, 0.2, duration=6.4, node=toon),
targetTrack)
track.append(Func(toon.loop, 'neutral'))
track.append(Wait(0.1))
track.append(mtrack)
if npcId != 0:
track.append(MovieNPCSOS.teleportOut(heal, toon))
else:
track.append(__returnToBase(heal))
for target in targets:
targetToon = target['toon']
track.append(Func(targetToon.clearChat))
return track
def __doElephant(sound, delay, toon, targets, level):
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(0.29999999999999999, 0.40000000000000002,
0.20000000000000001)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(0.29999999999999999, 0.29999999999999999,
0.29999999999999999)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch1 = Vec3(0.29999999999999999, 0.5, 0.25)
instrStretch1 *= INSTRUMENT_SCALE_MODIFIER
instrStretch2 = Vec3(0.29999999999999999, 0.69999999999999996,
0.29999999999999999)
instrStretch2 *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
instrument = globalPropPool.getProp('elephant')
instrument2 = MovieUtil.copyProp(instrument)
instruments = [instrument, instrument2]
def setInstrumentStats(instrument=instrument, instrument2=instrument2):
instrument.setPos(-0.59999999999999998, -0.90000000000000002,
0.14999999999999999)
instrument.setHpr(145, 0, 85)
instrument.setScale(instrMin)
instrument2.setPos(-0.59999999999999998, -0.90000000000000002,
0.14999999999999999)
instrument2.setHpr(145, 0, 85)
instrument2.setScale(instrMin)
hands = toon.getRightHands()
megaphoneShow = Sequence(Func(MovieUtil.showProps, megaphones, hands),
Func(MovieUtil.showProps, instruments, hands),
Func(setInstrumentStats))
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones),
Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(
appearSoundFiles[level])
grow1 = getScaleIntervals(instruments,
duration=0.29999999999999999,
startScale=instrMin,
endScale=instrMax1)
grow2 = getScaleIntervals(instruments,
duration=0.29999999999999999,
startScale=instrMax1,
endScale=instrMax2)
instrumentAppear = Parallel(
Sequence(grow1, grow2),
Sequence(Wait(0.050000000000000003),
SoundInterval(instrumentAppearSfx, node=toon)))
stretchInstr1 = getScaleBlendIntervals(instruments,
duration=0.10000000000000001,
startScale=instrMax2,
endScale=instrStretch1,
blendType='easeOut')
stretchInstr2 = getScaleBlendIntervals(instruments,
duration=0.10000000000000001,
startScale=instrStretch1,
endScale=instrStretch2,
blendType='easeOut')
stretchInstr = Sequence(stretchInstr1, stretchInstr2)
backInstr = getScaleBlendIntervals(instruments,
duration=0.10000000000000001,
startScale=instrStretch2,
endScale=instrMax2,
blendType='easeOut')
attackTrack = Sequence(stretchInstr, Wait(1), backInstr)
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
megaphoneTrack = Sequence(Wait(delayTime), megaphoneShow, Wait(1.0),
instrumentAppear, Wait(3.0), megaphoneHide)
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound, delay, toon)
tracks.append(toonTrack)
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
instrumentshrink = getScaleIntervals(instruments,
duration=0.10000000000000001,
startScale=instrMax2,
endScale=instrMin)
if soundEffect:
delayTime = delay + tSound
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Sequence(
Wait(delayTime),
Parallel(attackTrack, SoundInterval(soundEffect, node=toon),
Sequence(Wait(1.5), instrumentshrink)))
tracks.append(soundTrack)
return tracks
def __doStormCloud(squirt, delay, fShowStun):
toon = squirt['toon']
level = squirt['level']
hpbonus = squirt['hpbonus']
target = squirt['target']
suit = target['suit']
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
battle = squirt['battle']
suitPos = suit.getPos(battle)
origHpr = toon.getHpr(battle)
hitSuit = hp > 0
scale = sprayScales[level]
tButton = 0.0
dButtonScale = 0.5
dButtonHold = 3.0
tContact = 2.9
tSpray = 1
tSuitDodges = 1.8
tracks = Parallel()
soundTrack = __getSoundTrack(level, hitSuit, 2.3, toon)
soundTrack2 = __getSoundTrack(level, hitSuit, 4.6, toon)
tracks.append(soundTrack)
tracks.append(soundTrack2)
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
hands = toon.getLeftHands()
toonTrack = Sequence(Func(MovieUtil.showProps, buttons, hands),
Func(toon.headsUp, battle, suitPos),
ActorInterval(toon, 'pushbutton'),
Func(MovieUtil.removeProps, buttons),
Func(toon.loop, 'neutral'),
Func(toon.setHpr, battle, origHpr))
tracks.append(toonTrack)
cloud = globalPropPool.getProp('stormcloud')
cloud2 = MovieUtil.copyProp(cloud)
BattleParticles.loadParticles()
trickleEffect = BattleParticles.createParticleEffect(
file='trickleLiquidate')
rainEffect = BattleParticles.createParticleEffect(file='liquidate')
rainEffect2 = BattleParticles.createParticleEffect(file='liquidate')
rainEffect3 = BattleParticles.createParticleEffect(file='liquidate')
cloudHeight = suit.height + 3
cloudPosPoint = Point3(0, 0, cloudHeight)
scaleUpPoint = Point3(3, 3, 3)
rainEffects = [rainEffect, rainEffect2, rainEffect3]
rainDelay = 1
effectDelay = 0.3
if hp > 0:
cloudHold = 4.7
else:
cloudHold = 1.7
def getCloudTrack(cloud,
suit,
cloudPosPoint,
scaleUpPoint,
rainEffects,
rainDelay,
effectDelay,
cloudHold,
useEffect,
battle=battle,
trickleEffect=trickleEffect):
track = Sequence(
Func(MovieUtil.showProp, cloud, suit, cloudPosPoint),
Func(cloud.pose, 'stormcloud', 0),
LerpScaleInterval(cloud,
1.5,
scaleUpPoint,
startScale=MovieUtil.PNT3_NEARZERO),
Wait(rainDelay))
if useEffect == 1:
ptrack = Parallel()
delay = trickleDuration = cloudHold * 0.25
trickleTrack = Sequence(
Func(battle.movie.needRestoreParticleEffect, trickleEffect),
ParticleInterval(trickleEffect,
cloud,
worldRelative=0,
duration=trickleDuration,
cleanup=True),
Func(battle.movie.clearRestoreParticleEffect, trickleEffect))
track.append(trickleTrack)
for i in range(0, 3):
dur = cloudHold - 2 * trickleDuration
ptrack.append(
Sequence(
Func(battle.movie.needRestoreParticleEffect,
rainEffects[i]), Wait(delay),
ParticleInterval(rainEffects[i],
cloud,
worldRelative=0,
duration=dur,
cleanup=True),
Func(battle.movie.clearRestoreParticleEffect,
rainEffects[i])))
delay += effectDelay
ptrack.append(
Sequence(
Wait(3 * effectDelay),
ActorInterval(cloud,
'stormcloud',
startTime=1,
duration=cloudHold)))
track.append(ptrack)
else:
track.append(
ActorInterval(cloud,
'stormcloud',
startTime=1,
duration=cloudHold))
track.append(LerpScaleInterval(cloud, 0.5, MovieUtil.PNT3_NEARZERO))
track.append(Func(MovieUtil.removeProp, cloud))
return track
tracks.append(
getCloudTrack(cloud,
suit,
cloudPosPoint,
scaleUpPoint,
rainEffects,
rainDelay,
effectDelay,
cloudHold,
useEffect=1))
tracks.append(
getCloudTrack(cloud2,
suit,
cloudPosPoint,
scaleUpPoint,
rainEffects,
rainDelay,
effectDelay,
cloudHold,
useEffect=0))
if hp > 0 or delay <= 0:
tracks.append(
__getSuitTrack(suit,
tContact,
tSuitDodges,
hp,
hpbonus,
kbbonus,
'soak',
died,
leftSuits,
rightSuits,
battle,
toon,
fShowStun,
beforeStun=2.6,
afterStun=2.3,
revived=revived))
return tracks
def __doGeyser(squirt, delay, fShowStun, uberClone=0):
toon = squirt['toon']
level = squirt['level']
hpbonus = squirt['hpbonus']
tracks = Parallel()
tButton = 0.0
dButtonScale = 0.5
dButtonHold = 3.0
tContact = 2.9
tSpray = 1
tSuitDodges = 1.8
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
hands = toon.getLeftHands()
battle = squirt['battle']
origHpr = toon.getHpr(battle)
suit = squirt['target'][0]['suit']
suitPos = suit.getPos(battle)
toonTrack = Sequence(Func(MovieUtil.showProps, buttons, hands),
Func(toon.headsUp, battle, suitPos),
ActorInterval(toon, 'pushbutton'),
Func(MovieUtil.removeProps, buttons),
Func(toon.loop, 'neutral'),
Func(toon.setHpr, battle, origHpr))
tracks.append(toonTrack)
for target in squirt['target']:
suit = target['suit']
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
suitPos = suit.getPos(battle)
hitSuit = hp > 0
scale = sprayScales[level]
soundTrack = __getSoundTrack(level, hitSuit, 1.8, toon)
delayTime = random.random()
tracks.append(Wait(delayTime))
tracks.append(soundTrack)
cloud = globalPropPool.getProp('geyser')
cloud2 = MovieUtil.copyProp(cloud)
BattleParticles.loadParticles()
geyserHeight = battle.getH()
geyserPosPoint = Point3(0, 0, geyserHeight)
scaleUpPoint = Point3(1.8, 1.8, 1.8)
rainEffects = []
rainDelay = 2.5
effectDelay = 0.3
if hp > 0:
geyserHold = 1.5
else:
geyserHold = 0.5
def getGeyserTrack(geyser,
suit,
geyserPosPoint,
scaleUpPoint,
rainEffects,
rainDelay,
effectDelay,
geyserHold,
useEffect,
battle=battle):
geyserMound = MovieUtil.copyProp(geyser)
geyserRemoveM = geyserMound.findAllMatches('**/Splash*')
geyserRemoveM.addPathsFrom(geyserMound.findAllMatches('**/spout'))
for i in range(geyserRemoveM.getNumPaths()):
geyserRemoveM[i].removeNode()
geyserWater = MovieUtil.copyProp(geyser)
geyserRemoveW = geyserWater.findAllMatches('**/hole')
geyserRemoveW.addPathsFrom(geyserWater.findAllMatches('**/shadow'))
for i in range(geyserRemoveW.getNumPaths()):
geyserRemoveW[i].removeNode()
track = Sequence(
Wait(rainDelay),
Func(MovieUtil.showProp, geyserMound, battle,
suit.getPos(battle)),
Func(MovieUtil.showProp, geyserWater, battle,
suit.getPos(battle)),
LerpScaleInterval(geyserWater,
1.0,
scaleUpPoint,
startScale=MovieUtil.PNT3_NEARZERO),
Wait(geyserHold * 0.5),
LerpScaleInterval(geyserWater,
0.5,
MovieUtil.PNT3_NEARZERO,
startScale=scaleUpPoint))
track.append(
LerpScaleInterval(geyserMound, 0.5, MovieUtil.PNT3_NEARZERO))
track.append(Func(MovieUtil.removeProp, geyserMound))
track.append(Func(MovieUtil.removeProp, geyserWater))
track.append(Func(MovieUtil.removeProp, geyser))
return track
if not uberClone:
tracks.append(
Sequence(
Wait(delayTime),
getGeyserTrack(cloud,
suit,
geyserPosPoint,
scaleUpPoint,
rainEffects,
rainDelay,
effectDelay,
geyserHold,
useEffect=1)))
if hp > 0 or delay <= 0:
tracks.append(
Sequence(
Wait(delayTime),
__getSuitTrack(suit,
tContact,
tSuitDodges,
hp,
hpbonus,
kbbonus,
'soak',
died,
leftSuits,
rightSuits,
battle,
toon,
fShowStun,
beforeStun=2.6,
afterStun=2.3,
geyser=1,
uberRepeat=uberClone,
revived=revived)))
return tracks
def __doBikehorn(sound, delay, toon, targets, level):
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax = Vec3(0.65, 0.65, 0.65)
instrMax *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.6, 1.1, 0.6)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
if toon.isDisguised:
for m in megaphones:
m.setPos(-0.3, 0, 0.2)
m.setR(90)
print 'HI!!!!'
suitX, suitY, suitZ = m.getPos()
suitR = m.getR()
print suitX
print suitZ
instrument = globalPropPool.getProp('bikehorn')
instrument2 = MovieUtil.copyProp(instrument)
instruments = [instrument, instrument2]
def setInstrumentStats(instrument=instrument,
instrument2=instrument2,
suitX=suitX,
suitY=suitY,
suitZ=suitZ,
suitR=suitR):
print 'M'
instrument.setPos(-1.1 + suitX, -1.4 + suitY, 0.1 + suitZ)
instrument.setHpr(145, 0, suitR)
instrument.setScale(instrMin)
instrument2.setPos(-1.1 + suitX, -1.4 + suitY, 0.1 + suitZ)
instrument2.setHpr(145, 0, suitR)
instrument2.setScale(instrMin)
if toon.isDisguised:
hands = toon.suit.getRightHands()
else:
hands = toon.getRightHands()
megaphoneShow = Sequence(Func(MovieUtil.showProps, megaphones, hands),
Func(MovieUtil.showProps, instruments, hands),
Func(setInstrumentStats))
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones),
Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(
appearSoundFiles[level])
grow = getScaleIntervals(instruments,
duration=0.2,
startScale=instrMin,
endScale=instrMax)
instrumentAppear = Parallel(
grow,
Sequence(Wait(0.15), SoundInterval(instrumentAppearSfx, node=toon)))
stretchInstr = getScaleBlendIntervals(instruments,
duration=0.2,
startScale=instrMax,
endScale=instrStretch,
blendType='easeOut')
backInstr = getScaleBlendIntervals(instruments,
duration=0.2,
startScale=instrStretch,
endScale=instrMax,
blendType='easeIn')
stretchMega = getScaleBlendIntervals(megaphones,
duration=0.2,
startScale=megaphone.getScale(),
endScale=0.9,
blendType='easeOut')
backMega = getScaleBlendIntervals(megaphones,
duration=0.2,
startScale=0.9,
endScale=megaphone.getScale(),
blendType='easeIn')
attackTrack = Parallel(Sequence(stretchInstr, backInstr),
Sequence(stretchMega, backMega))
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
megaphoneTrack = Sequence(Wait(delayTime), megaphoneShow, Wait(1.0),
instrumentAppear, Wait(3.0), megaphoneHide)
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound, delay, toon)
tracks.append(toonTrack)
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
instrumentshrink = getScaleIntervals(instruments,
duration=0.1,
startScale=instrMax,
endScale=instrMin)
if soundEffect:
delayTime = delay + tSound
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Sequence(
Wait(delayTime),
Parallel(attackTrack, SoundInterval(soundEffect, node=toon)),
Wait(0.2), instrumentshrink)
tracks.append(soundTrack)
return tracks
def __doSoundsLevel(sounds, delay, hitCount):
lastSoundThatHit = None
totalDamage = 0
for sound in sounds:
for target in sound['target']:
if target['hp'] > 0:
lastSoundThatHit = sound
totalDamage += target['hp']
break
tracks = []
for sound in sounds:
toon = sound['toon']
level = sound['level']
targets = sound['target']
hpbonus = sound['hpbonus']
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
hands = toon.getRightHands()
megaphoneIntervals = []
megaphoneShow = FunctionInterval(MovieUtil.showProps,
extraArgs=[megaphones, hands])
megaphoneGrow = LerpScaleInterval(megaphone,
dMegaphoneGrow,
megaphone.getScale(),
startScale=Point3(0.01, 0.01, 0.01))
megaphoneShrink = LerpScaleInterval(megaphone, dMegaphoneShrink,
Point3(0.01, 0.01, 0.01),
megaphone.getScale())
megaphoneHide = FunctionInterval(MovieUtil.removeProps,
extraArgs=[megaphones])
megaphoneIntervals.append((delay, megaphoneShow))
megaphoneIntervals.append(megaphoneGrow)
megaphoneIntervals.append((delay + tMegaphoneShrink, megaphoneShrink))
megaphoneIntervals.append(megaphoneHide)
tracks.append(Track(megaphoneIntervals))
toonIntervals = []
toonSound = ActorInterval(toon, 'sound')
toonIntervals.append((delay, toonSound))
toonIntervals.append(FunctionInterval(toon.loop,
extraArgs=['neutral']))
tracks.append(Track(toonIntervals))
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
if soundEffect:
soundIntervals = []
playSound = SoundInterval(soundEffect, node=toon)
soundIntervals.append((delay + tSound, playSound))
tracks.append(Track(soundIntervals))
for target in targets:
suit = target['suit']
if totalDamage > 0 and sound == lastSoundThatHit:
hp = target['hp']
died = target['died']
battle = sound['battle']
kbbonus = target['kbbonus']
suitIntervals = []
showDamage = FunctionInterval(suit.showLaffNumber,
openEnded=0,
extraArgs=[-totalDamage])
updateHealthBar = FunctionInterval(suit.updateHealthBar,
extraArgs=[totalDamage])
suitIntervals.append((delay + tSuitReact, showDamage))
suitIntervals.append(updateHealthBar)
if hitCount == 1:
suitIntervals.append(
Parallel(
ActorInterval(suit, 'squirt-small-react'),
MovieUtil.createSuitStunInterval(suit, 0.5, 1.8)))
else:
suitIntervals.append(
ActorInterval(suit, 'squirt-small-react'))
if kbbonus == 0:
suitIntervals.append(
__createSuitResetPosTrack(suit, battle))
suitIntervals.append(Func(battle.unlureSuit, suit))
bonusTrack = None
if hpbonus > 0:
bonusTrack = Track([
(delay + tSuitReact + 0.75,
FunctionInterval(suit.showLaffNumber,
openEnded=0,
extraArgs=[-hpbonus, 1]))
])
if died != 0:
suitIntervals.append(
MovieUtil.createSuitDeathTrack(suit, toon, battle))
else:
suitIntervals.append(
FunctionInterval(suit.loop, extraArgs=['neutral']))
if bonusTrack == None:
tracks.append(Track(suitIntervals))
else:
tracks.append(
MultiTrack([Track(suitIntervals), bonusTrack]))
else:
if totalDamage <= 0:
tracks.append(
Track([(2.9,
FunctionInterval(MovieUtil.indicateMissed,
extraArgs=[suit, 1.0]))]))
return tracks
return
def __createMagnetMultiTrack(lure, magnet, pos, hpr, scale, isSmallMagnet=1):
toon = lure['toon']
battle = lure['battle']
sidestep = lure['sidestep']
targets = lure['target']
tracks = []
tracks.append(
Track([
ActorInterval(toon, 'hold-magnet'),
FunctionInterval(toon.loop, extraArgs=['neutral'])
]))
hands = toon.getLeftHands()
magnet2 = MovieUtil.copyProp(magnet)
magnets = [magnet, magnet2]
magnetIvals = []
magnetIvals.append(WaitInterval(0.7))
magnetIvals.append(
FunctionInterval(MovieUtil.showProps,
extraArgs=[magnets, hands, pos, hpr, scale]))
magnetIvals.append(WaitInterval(6.3))
magnetIvals.append(
FunctionInterval(MovieUtil.removeProps, extraArgs=[magnets]))
tracks.append(Track(magnetIvals))
for target in targets:
suit = target['suit']
trapProp = suit.battleTrapProp
if sidestep == 0:
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
if kbbonus == 1 or hp > 0:
suitDelay = 2.6
suitMoveDuration = 0.8
suitIvals = []
opos, ohpr = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
numShakes = 3.0
shakeTotalDuration = 0.8
shakeDuration = shakeTotalDuration / numShakes
suitAnims = []
suitAnims.append(
FunctionInterval(suit.loop, extraArgs=['neutral']))
suitAnims.append(WaitInterval(suitDelay))
suitAnims.append(
ActorInterval(suit,
'landing',
startTime=2.37,
endTime=1.82))
for i in range(0, numShakes):
suitAnims.append(
ActorInterval(suit,
'landing',
startTime=1.82,
endTime=1.16,
duration=shakeDuration))
suitAnims.append(
ActorInterval(suit, 'landing', startTime=1.16,
endTime=0.7))
suitAnims.append(
ActorInterval(suit, 'landing', startTime=0.7,
duration=1.3))
suitIvals.extend(suitAnims)
suitIvals.append(
FunctionInterval(suit.loop, extraArgs=['neutral']))
suitIvals.append(
FunctionInterval(battle.lureSuit, extraArgs=[suit]))
if hp > 0:
suitIvals.append(
__createSuitDamageTrack(battle, suit, hp, lure,
trapProp))
if died != 0:
suitIvals.append(
MovieUtil.createSuitDeathTrack(suit, toon, battle))
tracks.append(Track(suitIvals))
tracks.append(
lerpSuit(suit, suitDelay + 0.55 + shakeTotalDuration,
suitMoveDuration, reachPos, battle, trapProp))
else:
tracks.append(
Track([(3.7,
FunctionInterval(MovieUtil.indicateMissed,
extraArgs=[suit]))]))
if isSmallMagnet == 1:
tracks.append(
getSoundTrack('TL_small_magnet.mp3', delay=0.7, node=toon))
else:
tracks.append(
getSoundTrack('TL_large_magnet.mp3', delay=0.7, node=toon))
return MultiTrack(tracks)
def __createSlideshowMultiTrack(lure, npcs = []):
toon = lure['toon']
battle = lure['battle']
sidestep = lure['sidestep']
origHpr = toon.getHpr(battle)
slideshowDelay = 2.5
hands = toon.getLeftHands()
endPos = toon.getPos(battle)
endPos.setY(endPos.getY() + 4)
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
toonTrack = Sequence()
toonTrack.append(Func(MovieUtil.showProps, buttons, hands))
toonTrack.append(Func(toon.headsUp, battle, endPos))
toonTrack.append(ActorInterval(toon, 'pushbutton'))
toonTrack.append(Func(MovieUtil.removeProps, buttons))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
slideShowProp = globalPropPool.getProp('slideshow')
propTrack = Sequence()
propTrack.append(Wait(slideshowDelay))
propTrack.append(Func(slideShowProp.show))
propTrack.append(Func(slideShowProp.setScale, Point3(0.1, 0.1, 0.1)))
propTrack.append(Func(slideShowProp.reparentTo, battle))
propTrack.append(Func(slideShowProp.setPos, endPos))
propTrack.append(LerpScaleInterval(slideShowProp, 1.2, Point3(1.0, 1.0, 1.0)))
shrinkDuration = 0.4
totalDuration = 7.1
propTrackDurationAtThisPoint = propTrack.getDuration()
waitTime = totalDuration - propTrackDurationAtThisPoint - shrinkDuration
if waitTime > 0:
propTrack.append(Wait(waitTime))
propTrack.append(LerpScaleInterval(nodePath=slideShowProp, scale=Point3(1.0, 1.0, 0.1), duration=shrinkDuration))
propTrack.append(Func(MovieUtil.removeProp, slideShowProp))
tracks = Parallel(propTrack, toonTrack)
targets = lure['target']
for target in targets:
suit = target['suit']
trapProp = suit.battleTrapProp
if sidestep == 0:
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
if kbbonus == 1 or hp > 0:
suitTrack = Sequence()
suitDelay = 3.8
suitAnimDuration = 1.5
opos, ohpr = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
suitTrack.append(Func(suit.loop, 'neutral'))
suitTrack.append(Wait(suitDelay))
suitTrack.append(ActorInterval(suit, 'hypnotized', duration=3.1))
suitTrack.append(Func(suit.setPos, battle, reachPos))
suitTrack.append(Func(suit.loop, 'lured'))
suitTrack.append(Func(battle.lureSuit, suit))
if hp > 0:
suitTrack.append(__createSuitDamageTrack(battle, suit, hp, lure, trapProp))
if revived != 0:
suitTrack.append(MovieUtil.createSuitReviveTrack(suit, toon, battle, npcs))
elif died != 0:
if not (trapProp.getName() == 'tnt' and suit.maxHP <= 42):
suitTrack.append(MovieUtil.createSuitDeathTrack(suit, toon, battle, npcs))
tracks.append(suitTrack)
tracks.append(lerpSuit(suit, suitDelay + 1.7, 0.7, reachPos, battle, trapProp))
else:
tracks.append(Sequence(Wait(2.3), Func(MovieUtil.indicateMissed, suit, 1.1)))
tracks.append(getSoundTrack('TL_presentation.ogg', delay=2.3, node=toon))
tracks.append(getSoundTrack('AA_drop_trigger_box.ogg', delay=slideshowDelay, node=toon))
return tracks
def __createFishingPoleMultiTrack(lure, dollar, dollarName):
toon = lure['toon']
target = lure['target']
battle = lure['battle']
sidestep = lure['sidestep']
hp = target['hp']
kbbonus = target['kbbonus']
suit = target['suit']
targetPos = suit.getPos(battle)
died = target['died']
revived = target['revived']
reachAnimDuration = 3.5
trapProp = suit.battleTrapProp
pole = globalPropPool.getProp('fishing-pole')
pole2 = MovieUtil.copyProp(pole)
poles = [pole, pole2]
hands = toon.getRightHands()
def positionDollar(dollar, suit):
dollar.reparentTo(suit)
dollar.setPos(0, MovieUtil.SUIT_LURE_DOLLAR_DISTANCE, 0)
dollarTrack = Sequence(Func(positionDollar, dollar, suit), Func(dollar.wrtReparentTo, battle), ActorInterval(dollar, dollarName, duration=3), getSplicedLerpAnimsTrack(dollar, dollarName, 0.7, 2.0, startTime=3), LerpPosInterval(dollar, 0.2, Point3(0, -10, 7)), Func(MovieUtil.removeProp, dollar))
poleTrack = Sequence(Func(MovieUtil.showProps, poles, hands), ActorInterval(pole, 'fishing-pole'), Func(MovieUtil.removeProps, poles))
toonTrack = Sequence(Func(toon.headsUp, battle, targetPos), ActorInterval(toon, 'battlecast'), Func(toon.loop, 'neutral'))
tracks = Parallel(dollarTrack, poleTrack, toonTrack)
if sidestep == 0:
if kbbonus == 1 or hp > 0:
suitTrack = Sequence()
opos, ohpr = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
suitTrack.append(Func(suit.loop, 'neutral'))
suitTrack.append(Wait(3.5))
suitName = suit.getStyleName()
retardPos, retardHpr = battle.getActorPosHpr(suit)
retardPos.setY(retardPos.getY() + MovieUtil.SUIT_EXTRA_REACH_DISTANCE)
if suitName in MovieUtil.largeSuits:
moveTrack = lerpSuit(suit, 0.0, reachAnimDuration / 2.5, retardPos, battle, trapProp)
reachTrack = ActorInterval(suit, 'reach', duration=reachAnimDuration)
suitTrack.append(Parallel(moveTrack, reachTrack))
else:
suitTrack.append(ActorInterval(suit, 'reach', duration=reachAnimDuration))
if trapProp:
suitTrack.append(Func(trapProp.wrtReparentTo, battle))
suitTrack.append(Func(suit.setPos, battle, reachPos))
if trapProp:
suitTrack.append(Func(trapProp.wrtReparentTo, suit))
suit.battleTrapProp = trapProp
suitTrack.append(Func(suit.loop, 'lured'))
suitTrack.append(Func(battle.lureSuit, suit))
if hp > 0:
suitTrack.append(__createSuitDamageTrack(battle, suit, hp, lure, trapProp))
if revived != 0:
suitTrack.append(MovieUtil.createSuitReviveTrack(suit, toon, battle))
if died != 0:
if not (trapProp.getName() == 'tnt' and suit.maxHP <= 42):
suitTrack.append(MovieUtil.createSuitDeathTrack(suit, toon, battle))
tracks.append(suitTrack)
else:
tracks.append(Sequence(Wait(3.7), Func(MovieUtil.indicateMissed, suit)))
tracks.append(getSoundTrack('TL_fishing_pole.ogg', delay=0.5, node=toon))
return tracks
def __doGeyser(squirt, delay, fShowStun, uberClone = 0):
toon = squirt['toon']
level = squirt['level']
hpbonus = squirt['hpbonus']
tracks = Parallel()
tButton = 0.0
dButtonScale = 0.5
dButtonHold = 3.0
tContact = 2.9
tSpray = 1
tSuitDodges = 1.8
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
hands = toon.getLeftHands()
battle = squirt['battle']
origHpr = toon.getHpr(battle)
suit = squirt['target'][0]['suit']
suitPos = suit.getPos(battle)
toonTrack = Sequence(Func(MovieUtil.showProps, buttons, hands), Func(toon.headsUp, battle, suitPos), ActorInterval(toon, 'pushbutton'), Func(MovieUtil.removeProps, buttons), Func(toon.loop, 'neutral'), Func(toon.setHpr, battle, origHpr))
tracks.append(toonTrack)
for target in squirt['target']:
suit = target['suit']
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
suitPos = suit.getPos(battle)
hitSuit = hp > 0
scale = sprayScales[level]
soundTrack = __getSoundTrack(level, hitSuit, 1.8, toon)
delayTime = random.random()
tracks.append(Wait(delayTime))
tracks.append(soundTrack)
cloud = globalPropPool.getProp('geyser')
cloud2 = MovieUtil.copyProp(cloud)
BattleParticles.loadParticles()
geyserHeight = battle.getH()
geyserPosPoint = Point3(0, 0, geyserHeight)
scaleUpPoint = Point3(1.8, 1.8, 1.8)
rainEffects = []
rainDelay = 2.5
effectDelay = 0.3
if hp > 0:
geyserHold = 1.5
else:
geyserHold = 0.5
def getGeyserTrack(geyser, suit, geyserPosPoint, scaleUpPoint, rainEffects, rainDelay, effectDelay, geyserHold, useEffect, battle = battle):
geyserMound = MovieUtil.copyProp(geyser)
geyserRemoveM = geyserMound.findAllMatches('**/Splash*')
geyserRemoveM.addPathsFrom(geyserMound.findAllMatches('**/spout'))
for i in range(geyserRemoveM.getNumPaths()):
geyserRemoveM[i].removeNode()
geyserWater = MovieUtil.copyProp(geyser)
geyserRemoveW = geyserWater.findAllMatches('**/hole')
geyserRemoveW.addPathsFrom(geyserWater.findAllMatches('**/shadow'))
for i in range(geyserRemoveW.getNumPaths()):
geyserRemoveW[i].removeNode()
track = Sequence(Wait(rainDelay), Func(MovieUtil.showProp, geyserMound, battle, suit.getPos(battle)), Func(MovieUtil.showProp, geyserWater, battle, suit.getPos(battle)), LerpScaleInterval(geyserWater, 1.0, scaleUpPoint, startScale=MovieUtil.PNT3_NEARZERO), Wait(geyserHold * 0.5), LerpScaleInterval(geyserWater, 0.5, MovieUtil.PNT3_NEARZERO, startScale=scaleUpPoint))
track.append(LerpScaleInterval(geyserMound, 0.5, MovieUtil.PNT3_NEARZERO))
track.append(Func(MovieUtil.removeProp, geyserMound))
track.append(Func(MovieUtil.removeProp, geyserWater))
track.append(Func(MovieUtil.removeProp, geyser))
return track
if not uberClone:
tracks.append(Sequence(Wait(delayTime), getGeyserTrack(cloud, suit, geyserPosPoint, scaleUpPoint, rainEffects, rainDelay, effectDelay, geyserHold, useEffect=1)))
if hp > 0 or delay <= 0:
tracks.append(Sequence(Wait(delayTime), __getSuitTrack(suit, tContact, tSuitDodges, hp, hpbonus, kbbonus, 'soak', died, leftSuits, rightSuits, battle, toon, fShowStun, beforeStun=2.6, afterStun=2.3, geyser=1, uberRepeat=uberClone, revived=revived)))
return tracks
def __createPlacedGroupTrapTrack(
trap,
prop,
propName,
centerSuit,
propPos=None,
propHpr=None,
explode=0):
toon = trap['toon']
if 'npc' in trap:
toon = trap['npc']
level = trap['level']
battle = trap['battle']
origHpr = toon.getHpr(battle)
trapPoint = Point3(0, 5 - MovieUtil.SUIT_TRAP_DISTANCE, 0.025)
trapDelay = 2.5
hands = toon.getLeftHands()
def placeDustExplosion(dustNode, trapProp, battle):
dustNode.reparentTo(battle)
dustNode.setPos(trapProp.getPos(battle))
trapTracks = Parallel()
firstTime = 1
targets = trap['target']
if True:
suit = centerSuit
suitPos = suit.getPos(battle)
targetPos = suitPos
trapProp = MovieUtil.copyProp(prop)
showThisTrap = True
trapTrack = Sequence()
trapTrack.append(Wait(trapDelay))
if showThisTrap:
notify.debug(
'showing trap %s for %d' %
(trapProp.getName(), suit.doId))
trapTrack.append(Func(trapProp.show))
else:
notify.debug(
'hiding trap %s for %d' %
(trapProp.getName(), suit.doId))
trapTrack.append(Func(trapProp.hide))
trapTrack.append(Func(trapProp.setScale, Point3(0.1, 0.1, 0.1)))
trapTrack.append(Func(trapProp.reparentTo, battle))
trapTrack.append(Func(trapProp.setPos, trapPoint))
trapTrack.append(Func(trapProp.setH, 0))
trapTrack.append(
LerpScaleInterval(
trapProp, 1.2, Point3(
1.0, 1.0, 1.0)))
if explode == 1:
dustNode = hidden.attachNewNode('DustNode')
removeTrapsParallel = Parallel()
oneTrapTrack = Sequence()
oneTrapTrack.append(Func(trapProp.wrtReparentTo, hidden))
oneTrapTrack.append(
Func(
placeDustExplosion,
dustNode,
trapProp,
battle))
oneTrapTrack.append(
createCartoonExplosionTrack(
dustNode, 'dust', explosionPoint=Point3(
0, 0, 0)))
oneTrapTrack.append(Func(MovieUtil.removeProp, trapProp))
removeTrapsParallel.append(oneTrapTrack)
for target in trap['target']:
otherSuit = target['suit']
if otherSuit.battleTrapProp:
otherDustNode = hidden.attachNewNode('DustNodeOtherSuit')
otherTrapTrack = Sequence()
otherTrapTrack.append(
Func(
otherSuit.battleTrapProp.wrtReparentTo,
hidden))
otherTrapTrack.append(
Func(
placeDustExplosion,
dustNode,
otherSuit.battleTrapProp,
battle))
otherTrapTrack.append(
createCartoonExplosionTrack(
otherDustNode, 'dust',
explosionPoint=Point3(0, 0, 0)))
otherTrapTrack.append(Func(battle.removeTrap, otherSuit))
removeTrapsParallel.append(otherTrapTrack)
trapTrack.append(removeTrapsParallel)
else:
if suit.battleTrap != NO_TRAP:
notify.debug(
'trapSuit() - trap: %d destroyed existing trap: %d' %
(level, suit.battleTrap))
battle.removeTrap(suit)
suit.battleTrapProp = trapProp
suit.battleTrap = level
suit.battleTrapIsFresh = 1
unlureSuits = Parallel()
for target in targets:
kbbonus = target['kbbonus']
if kbbonus == 0:
unluredSuit = target['suit']
suitTrack = Sequence()
suitTrack.append(
createSuitResetPosTrack(
unluredSuit, battle))
suitTrack.append(Func(battle.unlureSuit, unluredSuit))
unlureSuits.append(suitTrack)
trapTrack.append(unlureSuits)
for otherSuit in battle.suits:
if not otherSuit == suit:
if otherSuit.battleTrap != NO_TRAP:
notify.debug(
'trapSuit() - trap: %d destroyed existing trap: %d' %
(level, suit.battleTrap))
battle.removeTrap(otherSuit)
otherSuit.battleTrapProp = trapProp
otherSuit.battleTrap = level
otherSuit.battleTrapIsFresh = 1
trapTracks.append(trapTrack)
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
toonTrack = Sequence()
toonTrack.append(Func(MovieUtil.showProps, buttons, hands))
toonTrack.append(Func(toon.headsUp, battle, suitPos))
toonTrack.append(ActorInterval(toon, 'pushbutton'))
toonTrack.append(Func(MovieUtil.removeProps, buttons))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
if propName == 'quicksand':
propSound = globalBattleSoundCache.getSound('TL_quicksand.ogg')
elif propName == 'traintrack':
propSound = globalBattleSoundCache.getSound(
'TL_train_track_appear.ogg')
else:
propSound = globalBattleSoundCache.getSound('TL_trap_door.ogg')
buttonSound = globalBattleSoundCache.getSound('AA_drop_trigger_box.ogg')
soundTrack = Sequence(
Wait(2.3), Parallel(
SoundInterval(
buttonSound, duration=0.67, node=toon), SoundInterval(
propSound, node=toon)))
return Parallel(trapTracks, toonTrack, soundTrack)
def __createPlacedTrapMultiTrack(
trap,
prop,
propName,
propPos=None,
propHpr=None,
explode=0,
visibleOnlyForThisSuitId=None):
toon = trap['toon']
if 'npc' in trap:
toon = trap['npc']
level = trap['level']
battle = trap['battle']
origHpr = toon.getHpr(battle)
trapPoint = Point3(0, MovieUtil.SUIT_TRAP_DISTANCE, 0.025)
trapDelay = 2.5
hands = toon.getLeftHands()
def placeDustExplosion(dustNode, trapProp, battle):
dustNode.reparentTo(battle)
dustNode.setPos(trapProp.getPos(battle))
trapTracks = Parallel()
firstTime = 1
targets = trap['target']
for target in targets:
suit = target['suit']
suitPos = suit.getPos(battle)
targetPos = suitPos
trapProp = MovieUtil.copyProp(prop)
showThisTrap = True
if visibleOnlyForThisSuitId and visibleOnlyForThisSuitId != suit.doId:
showThisTrap = False
trapTrack = Sequence()
trapTrack.append(Wait(trapDelay))
if showThisTrap:
notify.debug(
'showing trap %s for %d' %
(trapProp.getName(), suit.doId))
trapTrack.append(Func(trapProp.show))
else:
notify.debug(
'hiding trap %s for %d' %
(trapProp.getName(), suit.doId))
trapTrack.append(Func(trapProp.hide))
trapTrack.append(Func(trapProp.setScale, Point3(0.1, 0.1, 0.1)))
trapTrack.append(Func(trapProp.reparentTo, suit))
trapTrack.append(Func(trapProp.setPos, trapPoint))
trapTrack.append(
LerpScaleInterval(
trapProp, 1.2, Point3(
1.7, 1.7, 1.7)))
if explode == 1:
dustNode = hidden.attachNewNode('DustNode')
trapTrack.append(Func(trapProp.wrtReparentTo, hidden))
trapTrack.append(
Func(
placeDustExplosion,
dustNode,
trapProp,
battle))
trapTrack.append(
createCartoonExplosionTrack(
dustNode,
'dust',
explosionPoint=Point3(
0,
0,
0)))
trapTrack.append(Func(MovieUtil.removeProp, trapProp))
trapTrack.append(Func(battle.removeTrap, suit))
else:
if suit.battleTrap != NO_TRAP:
notify.debug(
'trapSuit() - trap: %d destroyed existing trap: %d' %
(level, suit.battleTrap))
battle.removeTrap(suit)
suit.battleTrapProp = trapProp
suit.battleTrap = level
suit.battleTrapIsFresh = 1
trapTracks.append(trapTrack)
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
toonTrack = Sequence()
toonTrack.append(Func(MovieUtil.showProps, buttons, hands))
toonTrack.append(Func(toon.headsUp, battle, suitPos))
toonTrack.append(ActorInterval(toon, 'pushbutton'))
toonTrack.append(Func(MovieUtil.removeProps, buttons))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
if propName == 'quicksand':
propSound = globalBattleSoundCache.getSound('TL_quicksand.ogg')
else:
propSound = globalBattleSoundCache.getSound('TL_trap_door.ogg')
buttonSound = globalBattleSoundCache.getSound('AA_drop_trigger_box.ogg')
soundTrack = Sequence(
Wait(2.3),
SoundInterval(
buttonSound,
duration=0.67,
node=toon),
Wait(0.3),
SoundInterval(
propSound,
duration=0.5,
node=toon))
return Parallel(trapTracks, toonTrack, soundTrack)
def doTraps(traps):
if len(traps) == 0:
return None, None
npcArrivals, npcDepartures, npcs = MovieNPCSOS.doNPCTeleports(traps)
hasUberTrapConflict = False
suitTrapsDict = {}
for trap in traps:
targets = trap['target']
if len(targets) == 1:
suitId = targets[0]['suit'].doId
if suitId in suitTrapsDict:
suitTrapsDict[suitId].append(trap)
else:
suitTrapsDict[suitId] = [trap]
else:
for target in targets:
suitId = target['suit'].doId
if suitId not in suitTrapsDict:
suitTrapsDict[suitId] = [trap]
break
if trap['level'] == UBER_GAG_LEVEL_INDEX:
if len(traps) > 1:
hasUberTrapConflict = True
for oneTarget in trap['target']:
suit = oneTarget['suit']
if suit.battleTrap != NO_TRAP:
hasUberTrapConflict = True
suitTrapLists = suitTrapsDict.values()
mtrack = Parallel()
for trapList in suitTrapLists:
trapPropList = []
for i in range(len(trapList)):
trap = trapList[i]
level = trap['level']
if level == 0:
banana = globalPropPool.getProp('banana')
banana2 = MovieUtil.copyProp(banana)
trapPropList.append([banana, banana2])
elif level == 1:
rake = globalPropPool.getProp('rake')
rake2 = MovieUtil.copyProp(rake)
rake.pose('rake', 0)
rake2.pose('rake', 0)
trapPropList.append([rake, rake2])
elif level == 2:
marbles = globalPropPool.getProp('marbles')
marbles2 = MovieUtil.copyProp(marbles)
trapPropList.append([marbles, marbles2])
elif level == 3:
trapPropList.append([globalPropPool.getProp('quicksand')])
elif level == 4:
trapPropList.append([globalPropPool.getProp('trapdoor')])
elif level == 5:
tnt = globalPropPool.getProp('tnt')
tnt2 = MovieUtil.copyProp(tnt)
trapPropList.append([tnt, tnt2])
elif level == 6:
tnt = globalPropPool.getProp('traintrack')
tnt2 = MovieUtil.copyProp(tnt)
trapPropList.append([tnt, tnt2])
else:
notify.warning(
'__doTraps() - Incorrect trap level: %d' %
level)
if len(trapList) == 1 and not hasUberTrapConflict:
ival = __doTrapLevel(trapList[0], trapPropList[0])
if ival:
mtrack.append(ival)
else:
subMtrack = Parallel()
for i in range(len(trapList)):
trap = trapList[i]
trapProps = trapPropList[i]
ival = __doTrapLevel(trap, trapProps, explode=1)
if ival:
subMtrack.append(ival)
mtrack.append(subMtrack)
trapTrack = Sequence(npcArrivals, mtrack, npcDepartures)
camDuration = mtrack.getDuration()
enterDuration = npcArrivals.getDuration()
exitDuration = npcDepartures.getDuration()
camTrack = MovieCamera.chooseTrapShot(
traps, camDuration, enterDuration, exitDuration)
return trapTrack, camTrack
def __throwGroupPie(throw, delay, groupHitDict):
toon = throw['toon']
battle = throw['battle']
level = throw['level']
sidestep = throw['sidestep']
hpbonus = throw['hpbonus']
numTargets = len(throw['target'])
avgSuitPos = calcAvgSuitPos(throw)
origHpr = toon.getHpr(battle)
toonTrack = Sequence()
toonFace = Func(toon.headsUp, battle, avgSuitPos)
toonTrack.append(Wait(delay))
toonTrack.append(toonFace)
toonTrack.append(ActorInterval(toon, 'throw'))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
suits = []
for i in xrange(numTargets):
suits.append(throw['target'][i]['suit'])
pieName = pieNames[level]
pie = globalPropPool.getProp(pieName)
pieType = globalPropPool.getPropType(pieName)
pie2 = MovieUtil.copyProp(pie)
pies = [pie, pie2]
hands = toon.getRightHands()
pieShow = Func(MovieUtil.showProps, pies, hands)
pieAnim = Func(__animProp, pies, pieName, pieType)
pieScale1 = LerpScaleInterval(pie, 1.0, pie.getScale() * 1.5, startScale=MovieUtil.PNT3_NEARZERO)
pieScale2 = LerpScaleInterval(pie2, 1.0, pie2.getScale() * 1.5, startScale=MovieUtil.PNT3_NEARZERO)
pieScale = Parallel(pieScale1, pieScale2)
piePreflight = Func(__propPreflightGroup, pies, suits, toon, battle)
pieTrack = Sequence(Wait(delay), pieShow, pieAnim, pieScale, Func(battle.movie.needRestoreRenderProp, pies[0]), Wait(tPieLeavesHand - 1.0), piePreflight)
if level == UBER_GAG_LEVEL_INDEX:
groupPieTracks = __createWeddingCakeFlight(throw, groupHitDict, pie, pies)
else:
notify.error('unhandled throw level %d' % level)
pieTrack.append(groupPieTracks)
didThrowHitAnyone = False
for i in xrange(numTargets):
target = throw['target'][i]
hitSuit = target['hp'] > 0
if hitSuit:
didThrowHitAnyone = True
soundTrack = __getSoundTrack(level, didThrowHitAnyone, toon)
groupSuitResponseTrack = Parallel()
for i in xrange(numTargets):
target = throw['target'][i]
suit = target['suit']
hitSuit = target['hp'] > 0
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
if hitSuit:
singleSuitResponseTrack = Sequence()
showDamage = Func(suit.showHpText, -hp, openEnded=0, attackTrack=THROW_TRACK)
updateHealthBar = Func(suit.updateHealthBar, hp)
sival = []
if kbbonus > 0:
suitPos, suitHpr = battle.getActorPosHpr(suit)
suitType = getSuitBodyType(suit.getStyleName())
animTrack = Sequence()
animTrack.append(ActorInterval(suit, 'pie-small-react', duration=0.2))
if suitType == 'a':
animTrack.append(ActorInterval(suit, 'slip-forward', startTime=2.43))
elif suitType == 'b':
animTrack.append(ActorInterval(suit, 'slip-forward', startTime=1.94))
elif suitType == 'c':
animTrack.append(ActorInterval(suit, 'slip-forward', startTime=2.58))
animTrack.append(Func(battle.unlureSuit, suit))
moveTrack = Sequence(Wait(0.2), LerpPosInterval(suit, 0.6, pos=suitPos, other=battle))
sival = Parallel(animTrack, moveTrack)
elif groupHitDict[suit.doId] == 1:
sival = Parallel(ActorInterval(suit, 'pie-small-react'), MovieUtil.createSuitStunInterval(suit, 0.3, 1.3))
else:
sival = ActorInterval(suit, 'pie-small-react')
singleSuitResponseTrack.append(Wait(delay + tPieHitsSuit))
singleSuitResponseTrack.append(showDamage)
singleSuitResponseTrack.append(updateHealthBar)
singleSuitResponseTrack.append(sival)
bonusTrack = Sequence(Wait(delay + tPieHitsSuit))
if kbbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(Func(suit.showHpText, -kbbonus, 2, openEnded=0, attackTrack=THROW_TRACK))
if hpbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(Func(suit.showHpText, -hpbonus, 1, openEnded=0, attackTrack=THROW_TRACK))
if revived != 0:
singleSuitResponseTrack.append(MovieUtil.createSuitReviveTrack(suit, toon, battle))
elif died != 0:
singleSuitResponseTrack.append(MovieUtil.createSuitDeathTrack(suit, toon, battle))
else:
singleSuitResponseTrack.append(Func(suit.loop, 'neutral'))
singleSuitResponseTrack = Parallel(singleSuitResponseTrack, bonusTrack)
else:
groupHitValues = groupHitDict.values()
if groupHitValues.count(0) == len(groupHitValues):
singleSuitResponseTrack = MovieUtil.createSuitDodgeMultitrack(delay + tSuitDodges, suit, leftSuits, rightSuits)
else:
singleSuitResponseTrack = Sequence(Wait(tPieHitsSuit - 0.1), Func(MovieUtil.indicateMissed, suit, 1.0))
groupSuitResponseTrack.append(singleSuitResponseTrack)
return [toonTrack,
pieTrack,
soundTrack,
groupSuitResponseTrack]
def __createWeddingCakeFlight(throw, groupHitDict, pie, pies):
toon = throw['toon']
battle = throw['battle']
level = throw['level']
sidestep = throw['sidestep']
hpbonus = throw['hpbonus']
numTargets = len(throw['target'])
pieName = pieNames[level]
splatName = 'splat-' + pieName
if pieName == 'wedding-cake':
splatName = 'splat-birthday-cake'
splat = globalPropPool.getProp(splatName)
splats = [splat]
for i in range(numTargets - 1):
splats.append(MovieUtil.copyProp(splat))
if toon.isDisguised:
hands = toon.suit.getRightHands()
else:
hands = toon.getRightHands()
ebicPie = MovieUtil.copyProp(pie)
ebicPie.reparentTo(hands[0])
ebicPie.hide()
splatType = globalPropPool.getPropType(splatName)
cakePartStrs = ['cake1', 'cake2', 'cake3', 'caketop']
cakeParts = []
for part in cakePartStrs:
cakeParts.append(pie.find('**/%s' % part))
for part in cakePartStrs:
cakeParts.append(ebicPie.find('**/%s' % part))
cakePartDivisions = {}
cakePartDivisions[1] = [[
cakeParts[0], cakeParts[1], cakeParts[2], cakeParts[3]
]]
cakePartDivisions[2] = [[cakeParts[0], cakeParts[1]],
[cakeParts[2], cakeParts[3]]]
cakePartDivisions[3] = [[cakeParts[0], cakeParts[1]], [cakeParts[2]],
[cakeParts[3]]]
cakePartDivisions[4] = [[cakeParts[0]], [cakeParts[1]], [cakeParts[2]],
[cakeParts[3]]]
cakePartDivisions[5] = [[cakeParts[0]], [cakeParts[1]], [cakeParts[2]],
[cakeParts[3]], [cakeParts[4]]]
cakePartDivisions[6] = [[cakeParts[0]], [cakeParts[1]], [cakeParts[2]],
[cakeParts[3]], [cakeParts[4]], [cakeParts[5]]]
cakePartDivisions[7] = [[cakeParts[0]], [cakeParts[1]], [cakeParts[2]],
[cakeParts[3]], [cakeParts[4]], [cakeParts[5]],
[cakeParts[6]]]
cakePartDivisions[8] = [[cakeParts[0]], [cakeParts[1]], [cakeParts[2]],
[cakeParts[3]], [cakeParts[4]], [cakeParts[5]],
[cakeParts[6]], [cakeParts[7]]]
cakePartDivToUse = cakePartDivisions[len(throw['target'])]
groupPieTracks = Parallel()
for i in range(numTargets):
target = throw['target'][i]
suit = target['suit']
hitSuit = target['hp'] > 0
singlePieTrack = Sequence()
if hitSuit:
piePartReparent = Func(reparentCakePart, pie, cakePartDivToUse[i])
singlePieTrack.append(piePartReparent)
cakePartTrack = Parallel()
for cakePart in cakePartDivToUse[i]:
pieFly = LerpPosInterval(cakePart,
tPieHitsSuit - tPieLeavesHand,
pos=MovieUtil.avatarFacePoint(
suit, other=battle),
name=pieFlyTaskName,
other=battle)
cakePartTrack.append(pieFly)
singlePieTrack.append(cakePartTrack)
pieRemoveCakeParts = Func(MovieUtil.removeProps,
cakePartDivToUse[i])
pieHide = Func(MovieUtil.removeProps, pies)
splatShow = Func(__showProp, splats[i], suit,
Point3(0, 0, suit.getHeight()))
splatBillboard = Func(__billboardProp, splats[i])
splatAnim = ActorInterval(splats[i], splatName)
splatHide = Func(MovieUtil.removeProp, splats[i])
singlePieTrack.append(pieRemoveCakeParts)
singlePieTrack.append(pieHide)
singlePieTrack.append(Func(battle.movie.clearRenderProp, pies[0]))
singlePieTrack.append(splatShow)
singlePieTrack.append(splatBillboard)
singlePieTrack.append(splatAnim)
singlePieTrack.append(splatHide)
else:
missDict = {}
if sidestep:
suitPoint = MovieUtil.avatarFacePoint(suit, other=battle)
else:
suitPoint = __suitMissPoint(suit, other=battle)
piePartReparent = Func(reparentCakePart, pie, cakePartDivToUse[i])
piePreMiss = Func(__piePreMissGroup, missDict, cakePartDivToUse[i],
suitPoint, battle)
pieMiss = LerpFunctionInterval(
__pieMissGroupLerpCallback,
extraArgs=[missDict],
duration=(tPieHitsSuit - tPieLeavesHand) * ratioMissToHit)
pieHide = Func(MovieUtil.removeProps, pies)
pieRemoveCakeParts = Func(MovieUtil.removeProps,
cakePartDivToUse[i])
singlePieTrack.append(piePartReparent)
singlePieTrack.append(piePreMiss)
singlePieTrack.append(pieMiss)
singlePieTrack.append(pieRemoveCakeParts)
singlePieTrack.append(pieHide)
singlePieTrack.append(Func(battle.movie.clearRenderProp, pies[0]))
groupPieTracks.append(singlePieTrack)
return groupPieTracks
def __throwPie(throw, delay, hitCount, showCannon=1):
toon = throw['toon']
hpbonus = throw['hpbonus']
target = throw['target']
suit = target['suit']
hp = target['hp']
kbbonus = target['kbbonus']
sidestep = throw['sidestep']
died = target['died']
revived = target['revived']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
level = throw['level']
battle = throw['battle']
suitPos = suit.getPos(battle)
origHpr = toon.getHpr(battle)
notify.debug('toon: %s throws tart at suit: %d for hp: %d died: %d' %
(toon.getName(), suit.doId, hp, died))
pieName = pieNames[0]
hitSuit = hp > 0
button = globalPropPool.getProp('button')
buttonType = globalPropPool.getPropType('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
hands = toon.getLeftHands()
toonTrack = Sequence()
toonFace = Func(toon.headsUp, battle, suitPos)
toonTrack.append(Wait(delay))
toonTrack.append(toonFace)
toonTrack.append(ActorInterval(toon, 'pushbutton'))
toonTrack.append(ActorInterval(toon, 'wave', duration=2.0))
toonTrack.append(ActorInterval(toon, 'duck'))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
buttonTrack = Sequence()
buttonShow = Func(MovieUtil.showProps, buttons, hands)
buttonScaleUp = LerpScaleInterval(button,
1.0,
button.getScale(),
startScale=Point3(0.01, 0.01, 0.01))
buttonScaleDown = LerpScaleInterval(button,
1.0,
Point3(0.01, 0.01, 0.01),
startScale=button.getScale())
buttonHide = Func(MovieUtil.removeProps, buttons)
buttonTrack.append(Wait(delay))
buttonTrack.append(buttonShow)
buttonTrack.append(buttonScaleUp)
buttonTrack.append(Wait(2.5))
buttonTrack.append(buttonScaleDown)
buttonTrack.append(buttonHide)
soundTrack = __getSoundTrack(level, hitSuit, toon)
suitResponseTrack = Sequence()
reactIval = Sequence()
if showCannon:
showDamage = Func(suit.showHpText, -hp, openEnded=0)
updateHealthBar = Func(suit.updateHealthBar, hp)
cannon = loader.loadModel('phase_4/models/minigames/toon_cannon')
barrel = cannon.find('**/cannon')
barrel.setHpr(0, 90, 0)
cannonHolder = render.attachNewNode('CannonHolder')
cannon.reparentTo(cannonHolder)
cannon.setPos(0, 0, -8.6)
cannonHolder.setPos(suit.getPos(render))
cannonHolder.setHpr(suit.getHpr(render))
cannonAttachPoint = barrel.attachNewNode('CannonAttach')
kapowAttachPoint = barrel.attachNewNode('kapowAttach')
scaleFactor = 1.6
iScale = 1 / scaleFactor
barrel.setScale(scaleFactor, 1, scaleFactor)
cannonAttachPoint.setScale(iScale, 1, iScale)
cannonAttachPoint.setPos(0, 6.7, 0)
kapowAttachPoint.setPos(0, -0.5, 1.9)
suit.reparentTo(cannonAttachPoint)
suit.setPos(0, 0, 0)
suit.setHpr(0, -90, 0)
suitLevel = suit.getActualLevel()
deep = 2.5 + suitLevel * 0.2
suitScale = 0.9
import math
suitScale = 0.9 - math.sqrt(suitLevel) * 0.1
sival = []
posInit = cannonHolder.getPos()
posFinal = Point3(posInit[0] + 0.0, posInit[1] + 0.0, posInit[2] + 7.0)
kapow = globalPropPool.getProp('kapow')
kapow.reparentTo(kapowAttachPoint)
kapow.hide()
kapow.setScale(0.25)
kapow.setBillboardPointEye()
smoke = loader.loadModel('phase_4/models/props/test_clouds')
smoke.reparentTo(cannonAttachPoint)
smoke.setScale(0.5)
smoke.hide()
smoke.setBillboardPointEye()
soundBomb = base.loader.loadSfx(
'phase_4/audio/sfx/MG_cannon_fire_alt.ogg')
playSoundBomb = SoundInterval(soundBomb, node=cannonHolder)
soundFly = base.loader.loadSfx(
'phase_4/audio/sfx/firework_whistle_01.ogg')
playSoundFly = SoundInterval(soundFly, node=cannonHolder)
soundCannonAdjust = base.loader.loadSfx(
'phase_4/audio/sfx/MG_cannon_adjust.ogg')
playSoundCannonAdjust = SoundInterval(soundCannonAdjust,
duration=0.6,
node=cannonHolder)
soundCogPanic = base.loader.loadSfx(
'phase_5/audio/sfx/ENC_cogafssm.ogg')
playSoundCogPanic = SoundInterval(soundCogPanic, node=cannonHolder)
reactIval = Parallel(
ActorInterval(suit, 'pie-small-react'),
Sequence(
Wait(0.0),
LerpPosInterval(cannonHolder,
2.0,
posFinal,
startPos=posInit,
blendType='easeInOut'),
Parallel(
LerpHprInterval(barrel,
0.6,
Point3(0, 45, 0),
startHpr=Point3(0, 90, 0),
blendType='easeIn'),
playSoundCannonAdjust), Wait(2.0),
Parallel(
LerpHprInterval(barrel,
0.6,
Point3(0, 90, 0),
startHpr=Point3(0, 45, 0),
blendType='easeIn'),
playSoundCannonAdjust),
LerpPosInterval(cannonHolder,
1.0,
posInit,
startPos=posFinal,
blendType='easeInOut')),
Sequence(
Wait(0.0),
Parallel(
ActorInterval(suit, 'flail'),
suit.scaleInterval(1.0, suitScale),
LerpPosInterval(suit, 0.25, Point3(0, -1.0, 0.0)),
Sequence(
Wait(0.25),
Parallel(
playSoundCogPanic,
LerpPosInterval(suit,
1.5,
Point3(0, -deep, 0.0),
blendType='easeIn')))), Wait(2.5),
Parallel(
playSoundBomb, playSoundFly,
Sequence(
Func(smoke.show),
Parallel(
LerpScaleInterval(smoke, 0.5, 3),
LerpColorScaleInterval(smoke, 0.5,
Vec4(2, 2, 2, 0))),
Func(smoke.hide)),
Sequence(Func(kapow.show), ActorInterval(kapow, 'kapow'),
Func(kapow.hide)),
LerpPosInterval(suit, 3.0, Point3(0, 150.0, 0.0)),
suit.scaleInterval(3.0, 0.01)), Func(suit.hide)))
if hitCount == 1:
sival = Sequence(
Parallel(reactIval,
MovieUtil.createSuitStunInterval(suit, 0.3, 1.3)),
Wait(0.0), Func(cannonHolder.remove))
else:
sival = reactIval
suitResponseTrack.append(Wait(delay + tPieHitsSuit))
suitResponseTrack.append(showDamage)
suitResponseTrack.append(updateHealthBar)
suitResponseTrack.append(sival)
bonusTrack = Sequence(Wait(delay + tPieHitsSuit))
if kbbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(Func(suit.showHpText, -kbbonus, 2, openEnded=0))
if hpbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(Func(suit.showHpText, -hpbonus, 1, openEnded=0))
suitResponseTrack = Parallel(suitResponseTrack, bonusTrack)
return [toonTrack, soundTrack, buttonTrack, suitResponseTrack]
def __doWhistle(sound, delay, toon, targets, level):
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax = Vec3(0.2, 0.2, 0.2)
instrMax *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.25, 0.25, 0.25)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
instrument = globalPropPool.getProp('whistle')
instrument2 = MovieUtil.copyProp(instrument)
instruments = [instrument, instrument2]
def setInstrumentStats(instrument=instrument, instrument2=instrument2):
instrument.setPos(-1.2, -1.3, 0.1)
instrument.setHpr(145, 0, 85)
instrument.setScale(instrMin)
instrument2.setPos(-1.2, -1.3, 0.1)
instrument2.setHpr(145, 0, 85)
instrument2.setScale(instrMin)
hands = toon.getRightHands()
megaphoneShow = Sequence(Func(MovieUtil.showProps, megaphones, hands),
Func(MovieUtil.showProps, instruments, hands),
Func(setInstrumentStats))
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones),
Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(
appearSoundFiles[level])
grow = getScaleIntervals(instruments,
duration=0.2,
startScale=instrMin,
endScale=instrMax)
instrumentAppear = Parallel(
grow,
Sequence(Wait(0.05), SoundInterval(instrumentAppearSfx, node=toon)))
stretchInstr = getScaleBlendIntervals(instruments,
duration=0.2,
startScale=instrMax,
endScale=instrStretch,
blendType='easeOut')
backInstr = getScaleBlendIntervals(instruments,
duration=0.2,
startScale=instrStretch,
endScale=instrMax,
blendType='easeIn')
attackTrack = Sequence(stretchInstr, backInstr)
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
megaphoneTrack = Sequence(Wait(delayTime), megaphoneShow, Wait(1.0),
instrumentAppear, Wait(3.0), megaphoneHide)
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound, delay, toon)
tracks.append(toonTrack)
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
instrumentshrink = getScaleIntervals(instruments,
duration=0.1,
startScale=instrMax,
endScale=instrMin)
if soundEffect:
delayTime = delay + tSound
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Sequence(
Wait(delayTime),
Parallel(attackTrack, SoundInterval(soundEffect, node=toon)),
Wait(0.2), instrumentshrink)
tracks.append(soundTrack)
return tracks
def __doSmooch(attack, hp=0):
toon = NPCToons.createLocalNPC(attack['npcId'])
if toon == None:
return
targets = attack['toons']
level = 2
battle = attack['battle']
track = Sequence(teleportIn(attack, toon))
lipstick = globalPropPool.getProp('lipstick')
lipstick2 = MovieUtil.copyProp(lipstick)
lipsticks = [lipstick, lipstick2]
rightHands = toon.getRightHands()
dScale = 0.5
lipstickTrack = Sequence(
Func(MovieUtil.showProps, lipsticks, rightHands,
Point3(-0.27, -0.24, -0.95), Point3(-118, -10.6, -25.9)),
MovieUtil.getScaleIntervals(lipsticks, dScale, MovieUtil.PNT3_NEARZERO,
MovieUtil.PNT3_ONE),
Wait(toon.getDuration('smooch') - 2.0 * dScale),
MovieUtil.getScaleIntervals(lipsticks, dScale, MovieUtil.PNT3_ONE,
MovieUtil.PNT3_NEARZERO))
lips = globalPropPool.getProp('lips')
dScale = 0.5
tLips = 2.5
tThrow = 115.0 / toon.getFrameRate('smooch')
dThrow = 0.5
def getLipPos(toon=toon):
toon.pose('smooch', 57)
toon.update(0)
hand = toon.getRightHands()[0]
return hand.getPos(render)
effectTrack = Sequence()
for target in targets:
lipcopy = MovieUtil.copyProp(lips)
lipsTrack = Sequence(
Wait(tLips), Func(MovieUtil.showProp, lipcopy, render, getLipPos),
Func(lipcopy.setBillboardPointWorld),
LerpScaleInterval(lipcopy,
dScale,
Point3(3, 3, 3),
startScale=MovieUtil.PNT3_NEARZERO),
Wait(tThrow - tLips - dScale),
LerpPosInterval(
lipcopy, dThrow,
Point3(target.getPos() + Point3(0, 0, target.getHeight()))),
Func(MovieUtil.removeProp, lipcopy))
delay = tThrow + dThrow
mtrack = Parallel(
lipstickTrack, lipsTrack, __getSoundTrack(level, 2, node=toon),
Sequence(ActorInterval(toon, 'smooch')),
Sequence(Wait(delay), ActorInterval(target, 'conked')),
Sequence(Wait(delay), Func(__healToon, target, hp)))
effectTrack.append(mtrack)
effectTrack.append(Func(MovieUtil.removeProps, lipsticks))
track.append(effectTrack)
track.append(teleportOut(attack, toon))
track.append(Func(target.clearChat))
return track
def __doFoghorn(sound, delay, toon, targets, level):
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(0.1, 0.1, 0.1)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(0.3, 0.3, 0.3)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.4, 0.4, 0.4)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
instrument = globalPropPool.getProp('fog_horn')
instrument2 = MovieUtil.copyProp(instrument)
instruments = [instrument, instrument2]
def setInstrumentStats(instrument=instrument, instrument2=instrument2):
instrument.setPos(-.8, -.9, 0.2)
instrument.setHpr(145, 0, 0)
instrument.setScale(instrMin)
instrument2.setPos(-.8, -.9, 0.2)
instrument2.setHpr(145, 0, 0)
instrument2.setScale(instrMin)
hands = toon.getRightHands()
megaphoneShow = Sequence(Func(MovieUtil.showProps, megaphones, hands),
Func(MovieUtil.showProps, instruments, hands),
Func(setInstrumentStats))
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones),
Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(
appearSoundFiles[level])
grow1 = getScaleIntervals(instruments,
duration=1,
startScale=instrMin,
endScale=instrMax1)
grow2 = getScaleIntervals(instruments,
duration=0.1,
startScale=instrMax1,
endScale=instrMax2)
instrumentAppear = Parallel(
Sequence(grow1, grow2),
Sequence(Wait(0.05), SoundInterval(instrumentAppearSfx, node=toon)))
stretchInstr = getScaleBlendIntervals(instruments,
duration=0.3,
startScale=instrMax2,
endScale=instrStretch,
blendType='easeOut')
backInstr = getScaleBlendIntervals(instruments,
duration=1.0,
startScale=instrStretch,
endScale=instrMin,
blendType='easeIn')
spinInstr1 = LerpHprInterval(instrument,
duration=1.5,
startHpr=Vec3(145, 0, 0),
hpr=Vec3(145, 0, 90),
blendType='easeInOut')
spinInstr2 = LerpHprInterval(instrument2,
duration=1.5,
startHpr=Vec3(145, 0, 0),
hpr=Vec3(145, 0, 90),
blendType='easeInOut')
spinInstr = Parallel(spinInstr1, spinInstr2)
attackTrack = Parallel(Sequence(Wait(0.2), spinInstr),
Sequence(stretchInstr, Wait(0.5), backInstr))
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
megaphoneTrack = Sequence(Wait(delayTime), megaphoneShow, Wait(1.0),
instrumentAppear, Wait(3.0), megaphoneHide)
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound, delay, toon)
tracks.append(toonTrack)
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
if soundEffect:
delayTime = delay + tSound
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Sequence(
Wait(delayTime),
Parallel(attackTrack, SoundInterval(soundEffect, node=toon)))
tracks.append(soundTrack)
return tracks
def __doFlower(squirt, delay, fShowStun):
toon = squirt['toon']
level = squirt['level']
hpbonus = squirt['hpbonus']
target = squirt['target']
suit = target['suit']
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
battle = squirt['battle']
suitPos = suit.getPos(battle)
origHpr = toon.getHpr(battle)
hitSuit = hp > 0
scale = sprayScales[level]
tTotalFlowerToonAnimationTime = 2.5
tFlowerFirstAppears = 1.0
dFlowerScaleTime = 0.5
tSprayStarts = tTotalFlowerToonAnimationTime
dSprayScale = 0.2
dSprayHold = 0.1
tContact = tSprayStarts + dSprayScale
tSuitDodges = tTotalFlowerToonAnimationTime
tracks = Parallel()
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
hands = toon.getLeftHands()
toonTrack = Sequence(Func(MovieUtil.showProps, buttons, hands),
Func(toon.headsUp, battle, suitPos),
ActorInterval(toon, 'pushbutton'),
Func(MovieUtil.removeProps, buttons),
Func(toon.loop, 'neutral'),
Func(toon.setHpr, battle, origHpr))
tracks.append(toonTrack)
tracks.append(
__getSoundTrack(level, hitSuit, tTotalFlowerToonAnimationTime - 0.4,
toon))
flower = globalPropPool.getProp('squirting-flower')
flower.setScale(1.5, 1.5, 1.5)
targetPoint = lambda suit=suit: __suitTargetPoint(suit)
def getSprayStartPos(flower=flower):
toon.update(0)
return flower.getPos(render)
sprayTrack = MovieUtil.getSprayTrack(battle,
WaterSprayColor,
getSprayStartPos,
targetPoint,
dSprayScale,
dSprayHold,
dSprayScale,
horizScale=scale,
vertScale=scale)
lodnames = toon.getLODNames()
toonlod0 = toon.getLOD(lodnames[0])
toonlod1 = toon.getLOD(lodnames[1])
if config.GetBool('want-new-anims', 1):
if not toonlod0.find('**/def_joint_attachFlower').isEmpty():
flower_joint0 = toonlod0.find('**/def_joint_attachFlower')
else:
flower_joint0 = toonlod0.find('**/joint_attachFlower')
if config.GetBool('want-new-anims', 1):
if not toonlod1.find('**/def_joint_attachFlower').isEmpty():
flower_joint1 = toonlod1.find('**/def_joint_attachFlower')
else:
flower_joint1 = toonlod1.find('**/joint_attachFlower')
flower_jointpath0 = flower_joint0.attachNewNode(
'attachFlower-InstanceNode')
flower_jointpath1 = flower_jointpath0.instanceTo(flower_joint1)
flowerTrack = Sequence(
Wait(tFlowerFirstAppears), Func(flower.reparentTo, flower_jointpath0),
LerpScaleInterval(flower,
dFlowerScaleTime,
flower.getScale(),
startScale=MovieUtil.PNT3_NEARZERO),
Wait(tTotalFlowerToonAnimationTime - dFlowerScaleTime -
tFlowerFirstAppears))
if hp <= 0:
flowerTrack.append(Wait(0.5))
flowerTrack.append(sprayTrack)
flowerTrack.append(
LerpScaleInterval(flower, dFlowerScaleTime, MovieUtil.PNT3_NEARZERO))
flowerTrack.append(Func(flower_jointpath1.removeNode))
flowerTrack.append(Func(flower_jointpath0.removeNode))
flowerTrack.append(Func(MovieUtil.removeProp, flower))
tracks.append(flowerTrack)
if hp > 0:
tracks.append(
__getSplashTrack(targetPoint, scale, tSprayStarts + dSprayScale,
battle))
if hp > 0 or delay <= 0:
tracks.append(
__getSuitTrack(suit,
tContact,
tSuitDodges,
hp,
hpbonus,
kbbonus,
'squirt-small-react',
died,
leftSuits,
rightSuits,
battle,
toon,
fShowStun,
revived=revived))
return tracks
def __dropObject(drop, delay, objName, level, alreadyDodged, alreadyTeased,
npcs, target, npcDrops):
toon = drop['toon']
repeatNPC = 0
battle = drop['battle']
if (drop.has_key('npc')):
toon = drop['npc']
if (npcDrops.has_key(toon)):
repeatNPC = 1
else:
npcDrops[toon] = 1
origHpr = Vec3(0, 0, 0)
else:
origHpr = toon.getHpr(battle)
hpbonus = drop['hpbonus']
suit = target['suit']
hp = target['hp']
hitSuit = (hp > 0)
died = target['died']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
kbbonus = target['kbbonus']
suitPos = suit.getPos(battle)
majorObject = (level >= 3)
if (repeatNPC == 0):
button = globalPropPool.getProp('button')
buttonType = globalPropPool.getPropType('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
hands = toon.getLeftHands()
object = globalPropPool.getProp(objName)
objectType = globalPropPool.getPropType(objName)
# The safe and weight are a bit too big
if (objName == 'weight'):
object.setScale(object.getScale() * 0.75)
elif (objName == 'safe'):
object.setScale(object.getScale() * 0.85)
# The object will likely animate far from its initial bounding
# volume while it drops. To work around this bug, we artificially
# change the object's bounding volume to be really big. In fact,
# we make it infinite, so it will never be culled while it's
# onscreen.
node = object.node()
node.setBounds(OmniBoundingVolume())
node.setFinal(1)
# create the soundTrack
soundTrack = __getSoundTrack(level, hitSuit, toon)
# toon pulls the button out, presses it, and puts it away
toonTrack = Sequence()
if (repeatNPC == 0):
toonFace = Func(toon.headsUp, battle, suitPos)
toonTrack.append(Wait(delay))
toonTrack.append(toonFace)
toonTrack.append(ActorInterval(toon, 'pushbutton'))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
# button scales up in toon's hand as he takes it out, and
# scales down to nothing as it is put away
buttonTrack = Sequence()
if (repeatNPC == 0):
buttonShow = Func(MovieUtil.showProps, buttons, hands)
buttonScaleUp = LerpScaleInterval(button,
1.0,
button.getScale(),
startScale=Point3(0.01, 0.01, 0.01))
buttonScaleDown = LerpScaleInterval(button,
1.0,
Point3(0.01, 0.01, 0.01),
startScale=button.getScale())
buttonHide = Func(MovieUtil.removeProps, buttons)
buttonTrack.append(Wait(delay))
buttonTrack.append(buttonShow)
buttonTrack.append(buttonScaleUp)
buttonTrack.append(Wait(2.5))
buttonTrack.append(buttonScaleDown)
buttonTrack.append(buttonHide)
# object appears above suit
objectTrack = Sequence()
def posObject(object, suit, level, majorObject, miss, battle=battle):
object.reparentTo(battle)
# Options for positioning a drop:
# 1) Any successful drop on an unlured suit - strikes at suit battle pos
# 2) Unsuccessful drops on an unlured suit that are of the largest three -
# these strike behind the suit (who shouldn't dodge)
# 3) The first three (smallest drops) on a lured suit strike the battle pos,
# where the larger ones get bumped back a bit.
if (battle.isSuitLured(suit)):
# suit is lured, strike at battle position
suitPos, suitHpr = battle.getActorPosHpr(suit)
object.setPos(suitPos)
object.setHpr(suitHpr)
if (level >= 3): # bump back larger drops
object.setY(object.getY() + 2)
else:
object.setPos(suit.getPos(battle))
object.setHpr(suit.getHpr(battle))
if (miss and level >= 3):
object.setY(object.getY(battle) + 5)
if not majorObject:
if not miss:
shoulderHeight = shoulderHeights[suit.style.body] * suit.scale
object.setZ(object.getPos(battle)[2] + shoulderHeight)
# fix up the Z offset of the prop
object.setZ(object.getPos(battle)[2] + objZOffsets[level])
# the object will need to scale down to nothing at some point
# and then it will immediately get deleted
# since we already have an animation interval playing,
# we need to put the scale on a separate track.
# to avoid cases where the object has been deleted,
# and the scale interval is still trying to scale the
# object, we'll put the animation and scale intervals into
# separate tracks, combine them into a track, and
# put the hide interval after the track.
objectTrack.append(Func(battle.movie.needRestoreRenderProp, object))
objInit = Func(posObject, object, suit, level, majorObject, (hp <= 0))
objectTrack.append(Wait(delay + tObjectAppears))
objectTrack.append(objInit)
# we can assume that all drop props are animated
if hp > 0 or (level == 1 or level == 2):
# prop hits the suit
#import pdb; pdb.set_trace()
if hasattr(object, 'getAnimControls'):
animProp = ActorInterval(object, objName)
shrinkProp = LerpScaleInterval(object,
dShrink,
Point3(0.01, 0.01, 0.01),
startScale=object.getScale())
objAnimShrink = ParallelEndTogether(animProp, shrinkProp)
objectTrack.append(objAnimShrink)
else:
# donald boat currently does not have animation
startingScale = objStartingScales[level]
object2 = MovieUtil.copyProp(object)
posObject(object2, suit, level, majorObject, (hp <= 0))
endingPos = object2.getPos()
startPos = Point3(endingPos[0], endingPos[1], endingPos[2] + 5)
startHpr = object2.getHpr()
endHpr = Point3(startHpr[0] + 90, startHpr[1], startHpr[2])
animProp = LerpPosInterval(object,
landFrames[level] / 24.0,
endingPos,
startPos=startPos)
shrinkProp = LerpScaleInterval(object,
dShrink,
Point3(0.01, 0.01, 0.01),
startScale=startingScale)
bounceProp = Effects.createZBounce(object, 2, endingPos, 0.5, 1.5)
#objAnimShrink = ParallelEndTogether(animProp, shrinkProp)
objAnimShrink = Sequence(Func(object.setScale, startingScale),
Func(object.setH, endHpr[0]), animProp,
bounceProp, Wait(1.5), shrinkProp)
objectTrack.append(objAnimShrink)
MovieUtil.removeProp(object2)
else:
# prop misses the suit
# only play the animation up to the point where it lands
if hasattr(object, 'getAnimControls'):
animProp = ActorInterval(object,
objName,
duration=landFrames[level] / 24.)
def poseProp(prop, animName, level):
prop.pose(animName, landFrames[level])
poseProp = Func(poseProp, object, objName, level)
wait = Wait(1.0)
shrinkProp = LerpScaleInterval(object,
dShrinkOnMiss,
Point3(0.01, 0.01, 0.01),
startScale=object.getScale())
objectTrack.append(animProp)
objectTrack.append(poseProp)
objectTrack.append(wait)
objectTrack.append(shrinkProp)
else:
#donald boat currently does not have animation
startingScale = objStartingScales[level]
object2 = MovieUtil.copyProp(object)
posObject(object2, suit, level, majorObject, (hp <= 0))
endingPos = object2.getPos()
startPos = Point3(endingPos[0], endingPos[1], endingPos[2] + 5)
startHpr = object2.getHpr()
endHpr = Point3(startHpr[0] + 90, startHpr[1], startHpr[2])
animProp = LerpPosInterval(object,
landFrames[level] / 24.0,
endingPos,
startPos=startPos)
shrinkProp = LerpScaleInterval(object,
dShrinkOnMiss,
Point3(0.01, 0.01, 0.01),
startScale=startingScale)
bounceProp = Effects.createZBounce(object, 2, endingPos, 0.5, 1.5)
#objAnimShrink = ParallelEndTogether(animProp, shrinkProp)
objAnimShrink = Sequence(Func(object.setScale, startingScale),
Func(object.setH, endHpr[0]), animProp,
bounceProp, Wait(1.5), shrinkProp)
objectTrack.append(objAnimShrink)
MovieUtil.removeProp(object2)
objectTrack.append(Func(MovieUtil.removeProp, object))
objectTrack.append(Func(battle.movie.clearRenderProp, object))
# we will see a shadow scale up before the object drops
dropShadow = MovieUtil.copyProp(suit.getShadowJoint())
if (level == 0):
dropShadow.setScale(0.5)
elif (level <= 2):
dropShadow.setScale(0.8)
elif (level == 3):
dropShadow.setScale(2.0)
elif (level == 4):
dropShadow.setScale(2.3)
else:
dropShadow.setScale(3.6)
def posShadow(dropShadow=dropShadow,
suit=suit,
battle=battle,
hp=hp,
level=level):
dropShadow.reparentTo(battle)
if (battle.isSuitLured(suit)):
# suit is lured, shadow at battle position
suitPos, suitHpr = battle.getActorPosHpr(suit)
dropShadow.setPos(suitPos)
dropShadow.setHpr(suitHpr)
if (level >= 3): # bump back larger drops
dropShadow.setY(dropShadow.getY() + 2)
else:
dropShadow.setPos(suit.getPos(battle))
dropShadow.setHpr(suit.getHpr(battle))
if (hp <= 0 and level >= 3):
dropShadow.setY(dropShadow.getY(battle) + 5)
# Raise the drop shadow to curb level
dropShadow.setZ(dropShadow.getZ() + 0.5)
shadowTrack = Sequence(
Wait(delay + tButtonPressed),
Func(battle.movie.needRestoreRenderProp, dropShadow),
Func(posShadow),
LerpScaleInterval(dropShadow,
tObjectAppears - tButtonPressed,
dropShadow.getScale(),
startScale=Point3(0.01, 0.01, 0.01)),
Wait(0.3),
Func(MovieUtil.removeProp, dropShadow),
Func(battle.movie.clearRenderProp, dropShadow),
)
return Parallel(toonTrack, soundTrack, buttonTrack, objectTrack,
shadowTrack)
def __dropObject(drop, delay, objName, level, alreadyDodged, alreadyTeased,
npcs, target, npcDrops):
toon = drop['toon']
repeatNPC = 0
battle = drop['battle']
if drop.has_key('npc'):
toon = drop['npc']
if npcDrops.has_key(toon):
repeatNPC = 1
else:
npcDrops[toon] = 1
origHpr = Vec3(0, 0, 0)
else:
origHpr = toon.getHpr(battle)
hpbonus = drop['hpbonus']
suit = target['suit']
hp = target['hp']
hitSuit = hp > 0
died = target['died']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
kbbonus = target['kbbonus']
suitPos = suit.getPos(battle)
majorObject = level >= 3
if repeatNPC == 0:
button = globalPropPool.getProp('button')
buttonType = globalPropPool.getPropType('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
hands = toon.getLeftHands()
object = globalPropPool.getProp(objName)
objectType = globalPropPool.getPropType(objName)
if objName == 'weight':
object.setScale(object.getScale() * 0.75)
elif objName == 'safe':
object.setScale(object.getScale() * 0.85)
node = object.node()
node.setBounds(OmniBoundingVolume())
node.setFinal(1)
soundTrack = __getSoundTrack(level, hitSuit, toon)
toonTrack = Sequence()
if repeatNPC == 0:
toonFace = Func(toon.headsUp, battle, suitPos)
toonTrack.append(Wait(delay))
toonTrack.append(toonFace)
toonTrack.append(ActorInterval(toon, 'pushbutton'))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
buttonTrack = Sequence()
if repeatNPC == 0:
buttonShow = Func(MovieUtil.showProps, buttons, hands)
buttonScaleUp = LerpScaleInterval(button,
1.0,
button.getScale(),
startScale=Point3(0.01, 0.01, 0.01))
buttonScaleDown = LerpScaleInterval(button,
1.0,
Point3(0.01, 0.01, 0.01),
startScale=button.getScale())
buttonHide = Func(MovieUtil.removeProps, buttons)
buttonTrack.append(Wait(delay))
buttonTrack.append(buttonShow)
buttonTrack.append(buttonScaleUp)
buttonTrack.append(Wait(2.5))
buttonTrack.append(buttonScaleDown)
buttonTrack.append(buttonHide)
objectTrack = Sequence()
def posObject(object, suit, level, majorObject, miss, battle=battle):
object.reparentTo(battle)
if battle.isSuitLured(suit):
suitPos, suitHpr = battle.getActorPosHpr(suit)
object.setPos(suitPos)
object.setHpr(suitHpr)
if level >= 3:
object.setY(object.getY() + 2)
else:
object.setPos(suit.getPos(battle))
object.setHpr(suit.getHpr(battle))
if miss and level >= 3:
object.setY(object.getY(battle) + 5)
if not majorObject:
if not miss:
shoulderHeight = shoulderHeights[suit.style.body] * suit.scale
object.setZ(object.getPos(battle)[2] + shoulderHeight)
object.setZ(object.getPos(battle)[2] + objZOffsets[level])
objectTrack.append(Func(battle.movie.needRestoreRenderProp, object))
objInit = Func(posObject, object, suit, level, majorObject, hp <= 0)
objectTrack.append(Wait(delay + tObjectAppears))
objectTrack.append(objInit)
if hp > 0 or level == 1 or level == 2:
if hasattr(object, 'getAnimControls'):
animProp = ActorInterval(object, objName)
shrinkProp = LerpScaleInterval(object,
dShrink,
Point3(0.01, 0.01, 0.01),
startScale=object.getScale())
objAnimShrink = ParallelEndTogether(animProp, shrinkProp)
objectTrack.append(objAnimShrink)
else:
startingScale = objStartingScales[level]
object2 = MovieUtil.copyProp(object)
posObject(object2, suit, level, majorObject, hp <= 0)
endingPos = object2.getPos()
startPos = Point3(endingPos[0], endingPos[1], endingPos[2] + 5)
startHpr = object2.getHpr()
endHpr = Point3(startHpr[0] + 90, startHpr[1], startHpr[2])
animProp = LerpPosInterval(object,
landFrames[level] / 24.0,
endingPos,
startPos=startPos)
shrinkProp = LerpScaleInterval(object,
dShrink,
Point3(0.01, 0.01, 0.01),
startScale=startingScale)
bounceProp = Effects.createZBounce(object, 2, endingPos, 0.5, 1.5)
objAnimShrink = Sequence(Func(object.setScale, startingScale),
Func(object.setH, endHpr[0]), animProp,
bounceProp, Wait(1.5), shrinkProp)
objectTrack.append(objAnimShrink)
MovieUtil.removeProp(object2)
elif hasattr(object, 'getAnimControls'):
animProp = ActorInterval(object,
objName,
duration=landFrames[level] / 24.0)
def poseProp(prop, animName, level):
prop.pose(animName, landFrames[level])
poseProp = Func(poseProp, object, objName, level)
wait = Wait(1.0)
shrinkProp = LerpScaleInterval(object,
dShrinkOnMiss,
Point3(0.01, 0.01, 0.01),
startScale=object.getScale())
objectTrack.append(animProp)
objectTrack.append(poseProp)
objectTrack.append(wait)
objectTrack.append(shrinkProp)
else:
startingScale = objStartingScales[level]
object2 = MovieUtil.copyProp(object)
posObject(object2, suit, level, majorObject, hp <= 0)
endingPos = object2.getPos()
startPos = Point3(endingPos[0], endingPos[1], endingPos[2] + 5)
startHpr = object2.getHpr()
endHpr = Point3(startHpr[0] + 90, startHpr[1], startHpr[2])
animProp = LerpPosInterval(object,
landFrames[level] / 24.0,
endingPos,
startPos=startPos)
shrinkProp = LerpScaleInterval(object,
dShrinkOnMiss,
Point3(0.01, 0.01, 0.01),
startScale=startingScale)
bounceProp = Effects.createZBounce(object, 2, endingPos, 0.5, 1.5)
objAnimShrink = Sequence(Func(object.setScale, startingScale),
Func(object.setH, endHpr[0]), animProp,
bounceProp, Wait(1.5), shrinkProp)
objectTrack.append(objAnimShrink)
MovieUtil.removeProp(object2)
objectTrack.append(Func(MovieUtil.removeProp, object))
objectTrack.append(Func(battle.movie.clearRenderProp, object))
dropShadow = MovieUtil.copyProp(suit.getShadowJoint())
if level == 0:
dropShadow.setScale(0.5)
elif level <= 2:
dropShadow.setScale(0.8)
elif level == 3:
dropShadow.setScale(2.0)
elif level == 4:
dropShadow.setScale(2.3)
else:
dropShadow.setScale(3.6)
def posShadow(dropShadow=dropShadow,
suit=suit,
battle=battle,
hp=hp,
level=level):
dropShadow.reparentTo(battle)
if battle.isSuitLured(suit):
suitPos, suitHpr = battle.getActorPosHpr(suit)
dropShadow.setPos(suitPos)
dropShadow.setHpr(suitHpr)
if level >= 3:
dropShadow.setY(dropShadow.getY() + 2)
else:
dropShadow.setPos(suit.getPos(battle))
dropShadow.setHpr(suit.getHpr(battle))
if hp <= 0 and level >= 3:
dropShadow.setY(dropShadow.getY(battle) + 5)
dropShadow.setZ(dropShadow.getZ() + 0.5)
shadowTrack = Sequence(
Wait(delay + tButtonPressed),
Func(battle.movie.needRestoreRenderProp, dropShadow), Func(posShadow),
LerpScaleInterval(dropShadow,
tObjectAppears - tButtonPressed,
dropShadow.getScale(),
startScale=Point3(0.01, 0.01, 0.01)), Wait(0.3),
Func(MovieUtil.removeProp, dropShadow),
Func(battle.movie.clearRenderProp, dropShadow))
return Parallel(toonTrack, soundTrack, buttonTrack, objectTrack,
shadowTrack)
def __doStormCloud(squirt, delay, fShowStun):
toon = squirt['toon']
level = squirt['level']
hpbonus = squirt['hpbonus']
target = squirt['target']
suit = target['suit']
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
battle = squirt['battle']
suitPos = suit.getPos(battle)
origHpr = toon.getHpr(battle)
hitSuit = hp > 0
scale = sprayScales[level]
tButton = 0.0
dButtonScale = 0.5
dButtonHold = 3.0
tContact = 2.9
tSpray = 1
tSuitDodges = 1.8
tracks = Parallel()
soundTrack = __getSoundTrack(level, hitSuit, 2.3, toon)
soundTrack2 = __getSoundTrack(level, hitSuit, 4.6, toon)
tracks.append(soundTrack)
tracks.append(soundTrack2)
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
hands = toon.getLeftHands()
toonTrack = Sequence(Func(MovieUtil.showProps, buttons, hands), Func(toon.headsUp, battle, suitPos), ActorInterval(toon, 'pushbutton'), Func(MovieUtil.removeProps, buttons), Func(toon.loop, 'neutral'), Func(toon.setHpr, battle, origHpr))
tracks.append(toonTrack)
cloud = globalPropPool.getProp('stormcloud')
cloud2 = MovieUtil.copyProp(cloud)
BattleParticles.loadParticles()
trickleEffect = BattleParticles.createParticleEffect(file='trickleLiquidate')
rainEffect = BattleParticles.createParticleEffect(file='liquidate')
rainEffect2 = BattleParticles.createParticleEffect(file='liquidate')
rainEffect3 = BattleParticles.createParticleEffect(file='liquidate')
cloudHeight = suit.height + 3
cloudPosPoint = Point3(0, 0, cloudHeight)
scaleUpPoint = Point3(3, 3, 3)
rainEffects = [rainEffect, rainEffect2, rainEffect3]
rainDelay = 1
effectDelay = 0.3
if hp > 0:
cloudHold = 4.7
else:
cloudHold = 1.7
def getCloudTrack(cloud, suit, cloudPosPoint, scaleUpPoint, rainEffects, rainDelay, effectDelay, cloudHold, useEffect, battle = battle, trickleEffect = trickleEffect):
track = Sequence(Func(MovieUtil.showProp, cloud, suit, cloudPosPoint), Func(cloud.pose, 'stormcloud', 0), LerpScaleInterval(cloud, 1.5, scaleUpPoint, startScale=MovieUtil.PNT3_NEARZERO), Wait(rainDelay))
if useEffect == 1:
ptrack = Parallel()
delay = trickleDuration = cloudHold * 0.25
trickleTrack = Sequence(Func(battle.movie.needRestoreParticleEffect, trickleEffect), ParticleInterval(trickleEffect, cloud, worldRelative=0, duration=trickleDuration, cleanup=True), Func(battle.movie.clearRestoreParticleEffect, trickleEffect))
track.append(trickleTrack)
for i in range(0, 3):
dur = cloudHold - 2 * trickleDuration
ptrack.append(Sequence(Func(battle.movie.needRestoreParticleEffect, rainEffects[i]), Wait(delay), ParticleInterval(rainEffects[i], cloud, worldRelative=0, duration=dur, cleanup=True), Func(battle.movie.clearRestoreParticleEffect, rainEffects[i])))
delay += effectDelay
ptrack.append(Sequence(Wait(3 * effectDelay), ActorInterval(cloud, 'stormcloud', startTime=1, duration=cloudHold)))
track.append(ptrack)
else:
track.append(ActorInterval(cloud, 'stormcloud', startTime=1, duration=cloudHold))
track.append(LerpScaleInterval(cloud, 0.5, MovieUtil.PNT3_NEARZERO))
track.append(Func(MovieUtil.removeProp, cloud))
return track
tracks.append(getCloudTrack(cloud, suit, cloudPosPoint, scaleUpPoint, rainEffects, rainDelay, effectDelay, cloudHold, useEffect=1))
tracks.append(getCloudTrack(cloud2, suit, cloudPosPoint, scaleUpPoint, rainEffects, rainDelay, effectDelay, cloudHold, useEffect=0))
if hp > 0 or delay <= 0:
tracks.append(__getSuitTrack(suit, tContact, tSuitDodges, hp, hpbonus, kbbonus, 'soak', died, leftSuits, rightSuits, battle, toon, fShowStun, beforeStun=2.6, afterStun=2.3, revived=revived))
return tracks
def __healJoke(heal, hasInteractivePropHealBonus):
npcId = 0
if 'npcId' in heal:
npcId = heal['npcId']
toon = NPCToons.createLocalNPC(npcId)
if toon == None:
return
else:
toon = heal['toon']
targets = heal['target']
ineffective = heal['sidestep']
level = heal['level']
jokeIndex = heal['hpbonus'] % len(TTLocalizer.ToonHealJokes)
if npcId != 0:
track = Sequence(MovieNPCSOS.teleportIn(heal, toon))
else:
track = Sequence(__runToHealSpot(heal))
tracks = Parallel()
fSpeakPunchline = 58
tSpeakSetup = 0.0
tSpeakPunchline = 3.0
dPunchLine = 3.0
tTargetReact = tSpeakPunchline + 1.0
dTargetLaugh = 1.5
tRunBack = tSpeakPunchline + dPunchLine
tDoSoundAnimation = tSpeakPunchline - float(
fSpeakPunchline) / toon.getFrameRate('sound')
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
hands = toon.getRightHands()
dMegaphoneScale = 0.5
tracks.append(
Sequence(
Wait(tDoSoundAnimation),
Func(MovieUtil.showProps, megaphones, hands),
MovieUtil.getScaleIntervals(megaphones, dMegaphoneScale,
MovieUtil.PNT3_NEARZERO,
MovieUtil.PNT3_ONE),
Wait(toon.getDuration('sound') - 2.0 * dMegaphoneScale),
MovieUtil.getScaleIntervals(megaphones, dMegaphoneScale,
MovieUtil.PNT3_ONE,
MovieUtil.PNT3_NEARZERO),
Func(MovieUtil.removeProps, megaphones)))
tracks.append(
Sequence(Wait(tDoSoundAnimation), ActorInterval(toon, 'sound')))
soundTrack = __getSoundTrack(level, 2.0, node=toon)
tracks.append(soundTrack)
joke = TTLocalizer.ToonHealJokes[jokeIndex]
tracks.append(
Sequence(Wait(tSpeakSetup),
Func(toon.setChatAbsolute, joke[0], CFSpeech | CFTimeout)))
tracks.append(
Sequence(Wait(tSpeakPunchline),
Func(toon.setChatAbsolute, joke[1], CFSpeech | CFTimeout)))
reactTrack = Sequence(Wait(tTargetReact))
for target in targets:
targetToon = target['toon']
hp = target['hp']
reactTrack.append(
Func(__healToon, targetToon, hp, ineffective,
hasInteractivePropHealBonus))
reactTrack.append(Wait(dTargetLaugh))
for target in targets:
targetToon = target['toon']
reactTrack.append(Func(targetToon.clearChat))
tracks.append(reactTrack)
if npcId != 0:
track.append(
Sequence(Wait(tRunBack), Func(toon.clearChat),
*MovieNPCSOS.teleportOut(heal, toon)))
else:
tracks.append(
Sequence(Wait(tRunBack), Func(toon.clearChat),
*__returnToBase(heal)))
track.append(tracks)
return track
def __doFlower(squirt, delay, fShowStun):
toon = squirt['toon']
level = squirt['level']
hpbonus = squirt['hpbonus']
target = squirt['target']
suit = target['suit']
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
battle = squirt['battle']
suitPos = suit.getPos(battle)
origHpr = toon.getHpr(battle)
hitSuit = hp > 0
scale = sprayScales[level]
tTotalFlowerToonAnimationTime = 2.5
tFlowerFirstAppears = 1.0
dFlowerScaleTime = 0.5
tSprayStarts = tTotalFlowerToonAnimationTime
dSprayScale = 0.2
dSprayHold = 0.1
tContact = tSprayStarts + dSprayScale
tSuitDodges = tTotalFlowerToonAnimationTime
tracks = Parallel()
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
hands = toon.getLeftHands()
toonTrack = Sequence(Func(MovieUtil.showProps, buttons, hands), Func(toon.headsUp, battle, suitPos), ActorInterval(toon, 'pushbutton'), Func(MovieUtil.removeProps, buttons), Func(toon.loop, 'neutral'), Func(toon.setHpr, battle, origHpr))
tracks.append(toonTrack)
tracks.append(__getSoundTrack(level, hitSuit, tTotalFlowerToonAnimationTime - 0.4, toon))
flower = globalPropPool.getProp('squirting-flower')
flower.setScale(1.5, 1.5, 1.5)
targetPoint = lambda suit = suit: __suitTargetPoint(suit)
def getSprayStartPos(flower = flower):
toon.update(0)
return flower.getPos(render)
sprayTrack = MovieUtil.getSprayTrack(battle, WaterSprayColor, getSprayStartPos, targetPoint, dSprayScale, dSprayHold, dSprayScale, horizScale=scale, vertScale=scale)
lodnames = toon.getLODNames()
toonlod0 = toon.getLOD(lodnames[0])
toonlod1 = toon.getLOD(lodnames[1])
if base.config.GetBool('want-new-anims', 1):
if not toonlod0.find('**/def_joint_attachFlower').isEmpty():
flower_joint0 = toonlod0.find('**/def_joint_attachFlower')
else:
flower_joint0 = toonlod0.find('**/joint_attachFlower')
if base.config.GetBool('want-new-anims', 1):
if not toonlod1.find('**/def_joint_attachFlower').isEmpty():
flower_joint1 = toonlod1.find('**/def_joint_attachFlower')
else:
flower_joint1 = toonlod1.find('**/joint_attachFlower')
flower_jointpath0 = flower_joint0.attachNewNode('attachFlower-InstanceNode')
flower_jointpath1 = flower_jointpath0.instanceTo(flower_joint1)
flowerTrack = Sequence(Wait(tFlowerFirstAppears), Func(flower.reparentTo, flower_jointpath0), LerpScaleInterval(flower, dFlowerScaleTime, flower.getScale(), startScale=MovieUtil.PNT3_NEARZERO), Wait(tTotalFlowerToonAnimationTime - dFlowerScaleTime - tFlowerFirstAppears))
if hp <= 0:
flowerTrack.append(Wait(0.5))
flowerTrack.append(sprayTrack)
flowerTrack.append(LerpScaleInterval(flower, dFlowerScaleTime, MovieUtil.PNT3_NEARZERO))
flowerTrack.append(Func(flower_jointpath1.removeNode))
flowerTrack.append(Func(flower_jointpath0.removeNode))
flowerTrack.append(Func(MovieUtil.removeProp, flower))
tracks.append(flowerTrack)
if hp > 0:
tracks.append(__getSplashTrack(targetPoint, scale, tSprayStarts + dSprayScale, battle))
if hp > 0 or delay <= 0:
tracks.append(__getSuitTrack(suit, tContact, tSuitDodges, hp, hpbonus, kbbonus, 'squirt-small-react', died, leftSuits, rightSuits, battle, toon, fShowStun, revived=revived))
return tracks
def __createThrownTrapMultiTrack(trap, propList, propName, propPos=None, propHpr=None, anim=0, explode=0):
toon = trap['toon']
level = trap['level']
battle = trap['battle']
target = trap['target']
suit = target[0]['suit']
targetPos = suit.getPos(battle)
thrownProp = propList[0]
unthrownProp = propList[1]
torso = toon.style.torso
torso = torso[0]
if torso == 'l':
throwDelay = 2.3
else:
if torso == 'm':
throwDelay = 2.3
else:
throwDelay = 1.9
throwDuration = 0.9
animBreakPoint = throwDelay + throwDuration
animDelay = 3.1
trapTrack = ToontownBattleGlobals.TRAP_TRACK
trapTrackNames = ToontownBattleGlobals.AvProps[trapTrack]
trapName = trapTrackNames[level]
if toon.isDisguised:
hands = toon.suit.getRightHands()
else:
hands = toon.getRightHands()
propTrack = Sequence()
if propPos and propHpr:
propTrack.append(Func(MovieUtil.showProps, propList, hands, propPos, propHpr))
else:
propTrack.append(Func(MovieUtil.showProps, propList, hands))
if anim == 1:
pTracks = Parallel()
for prop in propList:
pTracks.append(ActorInterval(prop, propName, duration=animBreakPoint))
propTrack.append(pTracks)
throwTrack = Sequence()
throwTrack.append(Wait(throwDelay))
throwTrack.append(Func(unthrownProp.reparentTo, hidden))
throwTrack.append(Func(toon.update))
if suit == base.localAvatar:
pass
else:
if suit.battleTrap != NO_TRAP:
notify.debug('trapSuit() - trap: %d destroyed existing trap: %d' % (level, suit.battleTrap))
battle.removeTrap(suit)
if trapName == 'rake':
trapProp = globalPropPool.getProp('rake-react')
else:
trapProp = MovieUtil.copyProp(thrownProp)
suit.battleTrapProp = trapProp
suit.battleTrap = level
suit.battleTrapIsFresh = 1
if trapName == 'banana':
if suit == base.localAvatar:
trapPoint = base.localAvatar.getPos()
trapHpr = base.localAvatar.getHpr()
else:
trapPoint, trapHpr = battle.getActorPosHpr(suit)
trapPoint.setY(MovieUtil.SUIT_TRAP_DISTANCE)
slidePoint = Vec3(trapPoint.getX(), trapPoint.getY() - 2, trapPoint.getZ())
throwingTrack = createThrowingTrack(thrownProp, slidePoint, duration=0.9, parent=battle)
moveTrack = LerpPosInterval(thrownProp, 0.8, pos=trapPoint, other=battle)
animTrack = ActorInterval(thrownProp, propName, startTime=animBreakPoint)
slideTrack = Parallel(moveTrack, animTrack)
motionTrack = Sequence(throwingTrack, slideTrack)
hprTrack = LerpHprInterval(thrownProp, 1.7, hpr=Point3(0, 0, 0))
soundTrack = getSoundTrack('TL_banana.ogg', node=toon)
scaleTrack = LerpScaleInterval(thrownProp, 1.7, scale=MovieUtil.PNT3_ONE)
throwTrack.append(Wait(0.25))
throwTrack.append(Func(thrownProp.wrtReparentTo, suit))
throwTrack.append(Parallel(motionTrack, hprTrack, scaleTrack, soundTrack))
else:
if trapName == 'tnt':
trapPoint, trapHpr = battle.getActorPosHpr(suit)
if config.GetBool('want-retro-mode', False):
trapPoint.setY(MovieUtil.SUIT_TRAP_TNT_DISTANCE - 3.9)
else:
trapPoint.setY(MovieUtil.SUIT_TRAP_TNT_DISTANCE - 5.03)
trapPoint.setZ(trapPoint.getZ() + 0.4)
throwingTrack = createThrowingTrack(thrownProp, trapPoint, duration=throwDuration, parent=battle)
if config.GetBool('want-retro-mode', False):
hprTrack = LerpHprInterval(thrownProp, 0.9, hpr=Point3(0, 90, 0))
else:
hprTrack = LerpHprInterval(thrownProp, 0.9, hpr=Point3(180, 90, 0))
scaleTrack = LerpScaleInterval(thrownProp, 0.9, scale=MovieUtil.PNT3_ONE)
soundTrack = getSoundTrack('TL_dynamite.ogg', delay=0.8, duration=0.7, node=suit)
if config.GetBool('want-retro-mode', False):
throwTrack.append(Wait(0.2))
throwTrack.append(Parallel(throwingTrack, hprTrack, scaleTrack, soundTrack))
else:
if trapName == 'marbles':
trapPoint, trapHpr = battle.getActorPosHpr(suit)
trapPoint.setY(MovieUtil.SUIT_TRAP_MARBLES_DISTANCE)
flingDuration = 0.2
rollDuration = 1.0
throwDuration = flingDuration + rollDuration
landPoint = Point3(0, trapPoint.getY() + 2, trapPoint.getZ())
throwPoint = Point3(0, trapPoint.getY(), trapPoint.getZ())
moveTrack = Sequence(Func(thrownProp.wrtReparentTo, suit), Func(thrownProp.setHpr, Point3(94, 0, 0)), LerpPosInterval(thrownProp, flingDuration, pos=landPoint, other=suit), LerpPosInterval(thrownProp, rollDuration, pos=throwPoint, other=suit))
animTrack = ActorInterval(thrownProp, propName, startTime=throwDelay + 0.9)
scaleTrack = LerpScaleInterval(thrownProp, throwDuration, scale=MovieUtil.PNT3_ONE)
soundTrack = getSoundTrack('TL_marbles.ogg', delay=0.1, node=toon)
throwTrack.append(Wait(0.2))
throwTrack.append(Parallel(moveTrack, animTrack, scaleTrack, soundTrack))
else:
if trapName == 'rake':
trapPoint, trapHpr = battle.getActorPosHpr(suit)
trapPoint.setY(MovieUtil.SUIT_TRAP_RAKE_DISTANCE)
throwDuration = 1.1
throwingTrack = createThrowingTrack(thrownProp, trapPoint, duration=throwDuration, parent=suit)
hprTrack = LerpHprInterval(thrownProp, throwDuration, hpr=VBase3(63.43, -90.0, 63.43))
scaleTrack = LerpScaleInterval(thrownProp, 0.9, scale=Point3(0.7, 0.7, 0.7))
soundTrack = SoundInterval(globalBattleSoundCache.getSound('TL_rake_throw_only.ogg'), duration=1.1, node=suit)
throwTrack.append(Wait(0.2))
throwTrack.append(Parallel(throwingTrack, hprTrack, scaleTrack, soundTrack))
else:
notify.warning('__createThrownTrapMultiTrack() - Incorrect trap: %s thrown from toon' % trapName)
def placeTrap(trapProp, suit, battle=battle, trapName=trapName):
if not trapProp or trapProp.isEmpty():
return
trapProp.wrtReparentTo(suit)
trapProp.show()
if trapName == 'rake':
trapProp.setPos(0, MovieUtil.SUIT_TRAP_RAKE_DISTANCE, 0)
trapProp.setHpr(Point3(0, 270, 0))
trapProp.setScale(Point3(0.7, 0.7, 0.7))
rakeOffset = MovieUtil.getSuitRakeOffset(suit)
trapProp.setY(trapProp.getY() + rakeOffset)
else:
if trapName == 'banana':
trapProp.setHpr(0, 0, 0)
trapProp.setPos(0, MovieUtil.SUIT_TRAP_DISTANCE, -0.35)
trapProp.pose(trapName, trapProp.getNumFrames(trapName) - 1)
else:
if trapName == 'marbles':
trapProp.setHpr(Point3(94, 0, 0))
trapProp.setPos(0, MovieUtil.SUIT_TRAP_MARBLES_DISTANCE, 0)
trapProp.pose(trapName, trapProp.getNumFrames(trapName) - 1)
else:
if trapName == 'tnt':
trapProp.setHpr(0, 90, 0)
trapProp.setPos(0, MovieUtil.SUIT_TRAP_TNT_DISTANCE, 0.4)
else:
notify.warning('placeTrap() - Incorrect trap: %s placed on a suit' % trapName)
dustNode = hidden.attachNewNode('DustNode')
if toon.isDisguised:
trapProp.setP(trapProp.getP() + 180)
def placeDustExplosion(dustNode=dustNode, thrownProp=thrownProp, battle=battle):
dustNode.reparentTo(battle)
dustNode.setPos(thrownProp.getPos(battle))
if explode == 1:
throwTrack.append(Func(thrownProp.wrtReparentTo, hidden))
throwTrack.append(Func(placeDustExplosion))
throwTrack.append(createCartoonExplosionTrack(dustNode, 'dust', explosionPoint=Point3(0, 0, 0)))
if suit != base.localAvatar:
throwTrack.append(Func(battle.removeTrap, suit))
else:
throwTrack.append(Func(placeTrap, trapProp, suit))
if trapName == 'tnt':
tip = trapProp.find('**/joint_attachEmitter')
sparks = BattleParticles.createParticleEffect(file='tnt')
trapProp.sparksEffect = sparks
throwTrack.append(Func(sparks.start, tip))
throwTrack.append(Func(MovieUtil.removeProps, propList))
if toon.isDisguised:
if toon.suit.style.body == 'c':
toonTrack = Sequence(Func(toon.headsUp, battle, targetPos), ActorInterval(toon.suit, 'throw-paper', playRate=0.95), Func(toon.suit.loop, 'neutral'))
else:
toonTrack = Sequence(Func(toon.headsUp, battle, targetPos), ActorInterval(toon.suit, 'throw-object', playRate=1.2), Func(toon.suit.loop, 'neutral'))
else:
toonTrack = Sequence(Func(toon.headsUp, battle, targetPos), ActorInterval(toon, 'toss'), Func(toon.loop, 'neutral'))
return Parallel(propTrack, throwTrack, toonTrack)
def __throwPie(throw, delay, hitCount):
toon = throw['toon']
hpbonus = throw['hpbonus']
target = throw['target']
suit = target['suit']
hp = target['hp']
kbbonus = target['kbbonus']
sidestep = throw['sidestep']
died = target['died']
revived = target['revived']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
level = throw['level']
battle = throw['battle']
suitPos = suit.getPos(battle)
origHpr = toon.getHpr(battle)
notify.debug('toon: %s throws tart at suit: %d for hp: %d died: %d' %
(toon.getName(), suit.doId, hp, died))
pieName = pieNames[level]
hitSuit = hp > 0
pie = globalPropPool.getProp(pieName)
pieType = globalPropPool.getPropType(pieName)
pie2 = MovieUtil.copyProp(pie)
pies = [pie, pie2]
hands = toon.getRightHands()
splatName = 'splat-' + pieName
if pieName == 'wedding-cake':
splatName = 'splat-birthday-cake'
splat = globalPropPool.getProp(splatName)
splatType = globalPropPool.getPropType(splatName)
toonTrack = Sequence()
toonFace = Func(toon.headsUp, battle, suitPos)
toonTrack.append(Wait(delay))
toonTrack.append(toonFace)
toonTrack.append(ActorInterval(toon, 'throw'))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
pieShow = Func(MovieUtil.showProps, pies, hands)
pieAnim = Func(__animProp, pies, pieName, pieType)
pieScale1 = LerpScaleInterval(pie,
1.0,
pie.getScale(),
startScale=MovieUtil.PNT3_NEARZERO)
pieScale2 = LerpScaleInterval(pie2,
1.0,
pie2.getScale(),
startScale=MovieUtil.PNT3_NEARZERO)
pieScale = Parallel(pieScale1, pieScale2)
piePreflight = Func(__propPreflight, pies, suit, toon, battle)
pieTrack = Sequence(Wait(delay), pieShow, pieAnim, pieScale,
Func(battle.movie.needRestoreRenderProp, pies[0]),
Wait(tPieLeavesHand - 1.0), piePreflight)
soundTrack = __getSoundTrack(level, hitSuit, toon)
if hitSuit:
pieFly = LerpPosInterval(pie,
tPieHitsSuit - tPieLeavesHand,
pos=MovieUtil.avatarFacePoint(suit,
other=battle),
name=pieFlyTaskName,
other=battle)
pieHide = Func(MovieUtil.removeProps, pies)
splatShow = Func(__showProp, splat, suit,
Point3(0, 0, suit.getHeight()))
splatBillboard = Func(__billboardProp, splat)
splatAnim = ActorInterval(splat, splatName)
splatHide = Func(MovieUtil.removeProp, splat)
pieTrack.append(pieFly)
pieTrack.append(pieHide)
pieTrack.append(Func(battle.movie.clearRenderProp, pies[0]))
pieTrack.append(splatShow)
pieTrack.append(splatBillboard)
pieTrack.append(splatAnim)
pieTrack.append(splatHide)
else:
missDict = {}
if sidestep:
suitPoint = MovieUtil.avatarFacePoint(suit, other=battle)
else:
suitPoint = __suitMissPoint(suit, other=battle)
piePreMiss = Func(__piePreMiss, missDict, pie, suitPoint, battle)
pieMiss = LerpFunctionInterval(
__pieMissLerpCallback,
extraArgs=[missDict],
duration=(tPieHitsSuit - tPieLeavesHand) * ratioMissToHit)
pieHide = Func(MovieUtil.removeProps, pies)
pieTrack.append(piePreMiss)
pieTrack.append(pieMiss)
pieTrack.append(pieHide)
pieTrack.append(Func(battle.movie.clearRenderProp, pies[0]))
if hitSuit:
suitResponseTrack = Sequence()
showDamage = Func(suit.showHpText,
-hp,
openEnded=0,
attackTrack=THROW_TRACK)
updateHealthBar = Func(suit.updateHealthBar, hp)
sival = []
if kbbonus > 0:
suitPos, suitHpr = battle.getActorPosHpr(suit)
suitType = getSuitBodyType(suit.getStyleName())
animTrack = Sequence()
animTrack.append(
ActorInterval(suit, 'pie-small-react', duration=0.2))
if suitType == 'a':
animTrack.append(
ActorInterval(suit, 'slip-forward', startTime=2.43))
elif suitType == 'b':
animTrack.append(
ActorInterval(suit, 'slip-forward', startTime=1.94))
elif suitType == 'c':
animTrack.append(
ActorInterval(suit, 'slip-forward', startTime=2.58))
animTrack.append(Func(battle.unlureSuit, suit))
moveTrack = Sequence(
Wait(0.2), LerpPosInterval(suit,
0.6,
pos=suitPos,
other=battle))
sival = Parallel(animTrack, moveTrack)
elif hitCount == 1:
sival = Parallel(ActorInterval(suit, 'pie-small-react'),
MovieUtil.createSuitStunInterval(suit, 0.3, 1.3))
else:
sival = ActorInterval(suit, 'pie-small-react')
suitResponseTrack.append(Wait(delay + tPieHitsSuit))
suitResponseTrack.append(showDamage)
suitResponseTrack.append(updateHealthBar)
notify.warning('Current HP:' + str(hp))
suitResponseTrack.append(sival)
bonusTrack = Sequence(Wait(delay + tPieHitsSuit))
if kbbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(
Func(suit.showHpText,
-kbbonus,
2,
openEnded=0,
attackTrack=THROW_TRACK))
bonusTrack.append(Func(suit.updateHealthBar, kbbonus))
if hpbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(
Func(suit.showHpText,
-hpbonus,
1,
openEnded=0,
attackTrack=THROW_TRACK))
bonusTrack.append(Func(suit.updateHealthBar, kbbonus))
if revived != 0:
suitResponseTrack.append(
MovieUtil.createSuitReviveTrack(suit, toon, battle))
elif died != 0:
suitResponseTrack.append(
MovieUtil.createSuitDeathTrack(suit, toon, battle))
else:
suitResponseTrack.append(Func(suit.loop, 'neutral'))
suitResponseTrack = Parallel(suitResponseTrack, bonusTrack)
else:
suitResponseTrack = MovieUtil.createSuitDodgeMultitrack(
delay + tSuitDodges, suit, leftSuits, rightSuits)
if not hitSuit and delay > 0:
return [toonTrack, soundTrack, pieTrack]
else:
return [toonTrack, soundTrack, pieTrack, suitResponseTrack]
def __createHypnoGogglesMultiTrack(lure):
toon = lure['toon']
targets = lure['target']
battle = lure['battle']
sidestep = lure['sidestep']
goggles = globalPropPool.getProp('hypno-goggles')
goggles2 = MovieUtil.copyProp(goggles)
bothGoggles = [goggles, goggles2]
pos = Point3(-1.03, 1.04, -0.3)
hpr = Point3(97.65, 46.18, -97.25)
scale = Point3(1.5, 1.5, 1.5)
hands = toon.getLeftHands()
gogglesIvals = []
gogglesIvals.append(WaitInterval(0.6))
gogglesIvals.append(
FunctionInterval(MovieUtil.showProps,
extraArgs=[bothGoggles, hands, pos, hpr, scale]))
gogglesIvals.append(ActorInterval(goggles, 'hypno-goggles', duration=2.2))
gogglesIvals.append(
FunctionInterval(MovieUtil.removeProps, extraArgs=[bothGoggles]))
gogglesTrack = Track(gogglesIvals)
toonTrack = Track([
ActorInterval(toon, 'hypnotize'),
FunctionInterval(toon.loop, extraArgs=['neutral'])
])
tracks = [gogglesTrack, toonTrack]
for target in targets:
suit = target['suit']
trapProp = suit.battleTrapProp
if sidestep == 0:
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
if kbbonus == 1 or hp > 0:
suitIvals = []
suitDelay = 1.6
suitAnimDuration = 1.5
opos, ohpr = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
suitIvals.append(
FunctionInterval(suit.loop, extraArgs=['neutral']))
suitIvals.append(WaitInterval(suitDelay))
suitIvals.append(
ActorInterval(suit, 'hypnotized', duration=3.1))
suitIvals.append(
FunctionInterval(suit.setPos, extraArgs=[battle,
reachPos]))
suitIvals.append(
FunctionInterval(suit.loop, extraArgs=['neutral']))
suitIvals.append(
FunctionInterval(battle.lureSuit, extraArgs=[suit]))
if hp > 0:
suitIvals.append(
__createSuitDamageTrack(battle, suit, hp, lure,
trapProp))
if died != 0:
suitIvals.append(
MovieUtil.createSuitDeathTrack(suit, toon, battle))
tracks.append(Track(suitIvals))
tracks.append(
lerpSuit(suit, suitDelay + 1.7, 0.7, reachPos, battle,
trapProp))
else:
tracks.append(
Track([(2.3,
FunctionInterval(MovieUtil.indicateMissed,
extraArgs=[suit, 1.1]))]))
tracks.append(getSoundTrack('TL_hypnotize.mp3', delay=0.5, node=toon))
return MultiTrack(tracks)
def __createPlacedGroupTrapTrack(trap, prop, propName, centerSuit, propPos=None, propHpr=None, explode=0):
toon = trap['toon']
if trap.has_key('npc'):
toon = trap['npc']
level = trap['level']
battle = trap['battle']
origHpr = toon.getHpr(battle)
trapPoint = Point3(0, 5 - MovieUtil.SUIT_TRAP_DISTANCE, 0.025)
trapDelay = 2.5
if toon.isDisguised:
hands = toon.suit.getLeftHands()
else:
hands = toon.getLeftHands()
def placeDustExplosion(dustNode, trapProp, battle):
dustNode.reparentTo(battle)
dustNode.setPos(trapProp.getPos(battle))
trapTracks = Parallel()
firstTime = 1
targets = trap['target']
scale = 1
if len(targets) >= 5 and propName == 'traintrack':
scale = 2
if True:
suit = centerSuit
suitPos = suit.getPos(battle)
targetPos = suitPos
trapProp = MovieUtil.copyProp(prop)
showThisTrap = True
trapTrack = Sequence()
trapTrack.append(Wait(trapDelay))
if showThisTrap:
notify.debug('showing trap %s for %d' % (trapProp.getName(), suit.doId))
trapTrack.append(Func(trapProp.show))
else:
notify.debug('hiding trap %s for %d' % (trapProp.getName(), suit.doId))
trapTrack.append(Func(trapProp.hide))
trapTrack.append(Func(trapProp.setScale, Point3(0.1, 0.1, 0.1) * scale))
trapTrack.append(Func(trapProp.reparentTo, battle))
trapTrack.append(Func(trapProp.setPos, trapPoint))
trapTrack.append(Func(trapProp.setH, 0))
trapTrack.append(LerpScaleInterval(trapProp, 1.2, Point3(1.0, 1.0, 1.0) * scale))
if explode == 1:
dustNode = hidden.attachNewNode('DustNode')
removeTrapsParallel = Parallel()
oneTrapTrack = Sequence()
oneTrapTrack.append(Func(trapProp.wrtReparentTo, hidden))
oneTrapTrack.append(Func(placeDustExplosion, dustNode, trapProp, battle))
oneTrapTrack.append(createCartoonExplosionTrack(dustNode, 'dust', explosionPoint=Point3(0, 0, 0)))
oneTrapTrack.append(Func(MovieUtil.removeProp, trapProp))
removeTrapsParallel.append(oneTrapTrack)
for target in trap['target']:
otherSuit = target['suit']
if otherSuit.battleTrapProp:
otherDustNode = hidden.attachNewNode('DustNodeOtherSuit')
otherTrapTrack = Sequence()
otherTrapTrack.append(Func(otherSuit.battleTrapProp.wrtReparentTo, hidden))
otherTrapTrack.append(Func(placeDustExplosion, dustNode, otherSuit.battleTrapProp, battle))
otherTrapTrack.append(createCartoonExplosionTrack(otherDustNode, 'dust', explosionPoint=Point3(0, 0, 0)))
otherTrapTrack.append(Func(battle.removeTrap, otherSuit))
removeTrapsParallel.append(otherTrapTrack)
trapTrack.append(removeTrapsParallel)
else:
if suit.battleTrap != NO_TRAP:
notify.debug('trapSuit() - trap: %d destroyed existing trap: %d' % (level, suit.battleTrap))
battle.removeTrap(suit)
suit.battleTrapProp = trapProp
suit.battleTrap = level
suit.battleTrapIsFresh = 1
unlureSuits = Parallel()
for target in targets:
kbbonus = target['kbbonus']
if kbbonus == 0:
unluredSuit = target['suit']
suitTrack = Sequence()
suitTrack.append(createSuitResetPosTrack(unluredSuit, battle))
suitTrack.append(Func(battle.unlureSuit, unluredSuit))
unlureSuits.append(suitTrack)
trapTrack.append(unlureSuits)
for otherSuit in battle.suits:
if not otherSuit == suit:
if otherSuit.battleTrap != NO_TRAP:
notify.debug('trapSuit() - trap: %d destroyed existing trap: %d' % (level, suit.battleTrap))
battle.removeTrap(otherSuit)
otherSuit.battleTrapProp = trapProp
otherSuit.battleTrap = level
otherSuit.battleTrapIsFresh = 1
trapTracks.append(trapTrack)
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
if toon.isDisguised:
for b in buttons:
b.setP(180)
toonTrack = Sequence()
toonTrack.append(Func(MovieUtil.showProps, buttons, hands))
toonTrack.append(Func(toon.headsUp, battle, suitPos))
if toon.isDisguised:
if toon.suit.style.body == 'c':
toonTrack.append(Func(toon.suit.pose, 'phone', 0))
if toon.suit.style.body == 'a':
toonTrack.append(Sequence(Wait(1), ActorInterval(toon.suit, 'phone', endFrame=26, playRate=0.8), ActorInterval(toon.suit, 'phone', startFrame=26, endFrame=0)))
elif toon.suit.style.body == 'b':
toonTrack.append(Sequence(Wait(1), ActorInterval(toon.suit, 'phone', endFrame=32), ActorInterval(toon.suit, 'phone', startFrame=32, endFrame=0)))
else:
toonTrack.append(Sequence(Wait(1), ActorInterval(toon.suit, 'phone', endFrame=29), ActorInterval(toon.suit, 'phone', startFrame=29, endFrame=0)))
else:
toonTrack.append(ActorInterval(toon, 'pushbutton'))
toonTrack.append(Func(MovieUtil.removeProps, buttons))
if toon.isDisguised:
toonTrack.append(Func(toon.suit.loop, 'neutral'))
else:
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
if propName == 'quicksand':
propSound = globalBattleSoundCache.getSound('TL_quicksand.ogg')
else:
if propName == 'traintrack':
propSound = globalBattleSoundCache.getSound('TL_train_track_appear.ogg')
else:
propSound = globalBattleSoundCache.getSound('TL_trap_door.ogg')
buttonSound = globalBattleSoundCache.getSound('AA_drop_trigger_box.ogg')
soundTrack = Sequence(Wait(2.3), Parallel(SoundInterval(buttonSound, duration=0.67, node=toon), SoundInterval(propSound, node=toon)))
return Parallel(trapTracks, toonTrack, soundTrack)
def __throwGroupPie(throw, delay, groupHitDict):
toon = throw['toon']
battle = throw['battle']
level = throw['level']
sidestep = throw['sidestep']
hpbonus = throw['hpbonus']
numTargets = len(throw['target'])
avgSuitPos = calcAvgSuitPos(throw)
origHpr = toon.getHpr(battle)
toonTrack = Sequence()
toonFace = Func(toon.headsUp, battle, avgSuitPos)
toonTrack.append(Wait(delay))
toonTrack.append(toonFace)
if toon.isDisguised:
if toon.suit.style.body == 'c':
toonTrack.append(
ActorInterval(toon.suit, 'throw-paper', playRate=0.9))
else:
toonTrack.append(
ActorInterval(toon.suit, 'throw-object', playRate=1.15))
toonTrack.append(Func(toon.suit.loop, 'neutral'))
else:
toonTrack.append(ActorInterval(toon, 'throw'))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
suits = []
for i in range(numTargets):
suits.append(throw['target'][i]['suit'])
pieName = pieNames[level]
pie = globalPropPool.getProp(pieName)
pieType = globalPropPool.getPropType(pieName)
pie2 = MovieUtil.copyProp(pie)
pies = [pie, pie2]
if toon.isDisguised:
hands = toon.suit.getRightHands()
pieShow = Sequence(Func(MovieUtil.showProps, pies, hands),
Func(pie2.setP, 180), Func(pie.hide))
else:
hands = toon.getRightHands()
pieShow = Func(MovieUtil.showProps, pies, hands)
pieAnim = Func(__animProp, pies, pieName, pieType)
pieScale1 = LerpScaleInterval(pie,
1.0,
pie.getScale() * 1.5,
startScale=MovieUtil.PNT3_NEARZERO)
pieScale2 = LerpScaleInterval(pie2,
1.0,
pie2.getScale() * 1.5,
startScale=MovieUtil.PNT3_NEARZERO)
pieScale = Parallel(pieScale1, pieScale2)
piePreflight = Func(__propPreflightGroup, pies, suits, toon, battle)
pieTrack = Sequence(Wait(delay), pieShow, pieAnim, pieScale,
Func(battle.movie.needRestoreRenderProp, pies[0]),
Wait(tPieLeavesHand - 1.0), piePreflight)
if level == UBER_GAG_LEVEL_INDEX:
groupPieTracks = __createWeddingCakeFlight(throw, groupHitDict, pie,
pies)
else:
notify.error('unhandled throw level %d' % level)
pieTrack.append(groupPieTracks)
didThrowHitAnyone = False
for i in range(numTargets):
target = throw['target'][i]
hitSuit = target['hp'] > 0
if hitSuit:
didThrowHitAnyone = True
soundTrack = __getSoundTrack(level, didThrowHitAnyone, toon)
groupSuitResponseTrack = Parallel()
for i in range(numTargets):
target = throw['target'][i]
suit = target['suit']
hitSuit = target['hp'] > 0
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
if hitSuit:
singleSuitResponseTrack = Sequence()
showDamage = Func(suit.showHpText,
-hp,
openEnded=0,
attackTrack=THROW_TRACK)
updateHealthBar = Func(suit.updateHealthBar, hp)
sival = []
if kbbonus > 0:
suitPos, suitHpr = battle.getActorPosHpr(suit)
suitType = getSuitBodyType(suit.getStyleName())
animTrack = Sequence()
animTrack.append(
ActorInterval(suit, 'pie-small-react', duration=0.2))
if suit.isBoss:
animTrack.append(ActorInterval(suit.suitBoss,
'Fb_downHit'))
else:
if suitType == 'a':
animTrack.append(
ActorInterval(suit, 'slip-forward',
startTime=2.43))
else:
if suitType == 'b':
animTrack.append(
ActorInterval(suit,
'slip-forward',
startTime=1.94))
else:
if suitType == 'c':
animTrack.append(
ActorInterval(suit,
'slip-forward',
startTime=2.58))
animTrack.append(Func(battle.unlureSuit, suit))
moveTrack = Sequence(
Wait(0.2),
LerpPosInterval(suit, 0.6, pos=suitPos, other=battle))
sival = Parallel(animTrack, moveTrack)
else:
if groupHitDict[suit.doId] == 1:
if suit.isBoss:
sival = Parallel(
ActorInterval(suit.suitBoss, 'Fb_downHit'),
MovieUtil.createSuitStunInterval(suit, 0.3, 1.3))
else:
sival = Parallel(
ActorInterval(suit, 'pie-small-react'),
MovieUtil.createSuitStunInterval(suit, 0.3, 1.3))
else:
if suit.isBoss:
sival = ActorInterval(suit.suitBoss, 'Fb_downHit')
else:
sival = ActorInterval(suit, 'pie-small-react')
singleSuitResponseTrack.append(Wait(delay + tPieHitsSuit))
singleSuitResponseTrack.append(showDamage)
singleSuitResponseTrack.append(updateHealthBar)
singleSuitResponseTrack.append(sival)
bonusTrack = Sequence(Wait(delay + tPieHitsSuit))
if kbbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(
Func(suit.showHpText,
-kbbonus,
2,
openEnded=0,
attackTrack=THROW_TRACK))
if hpbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(
Func(suit.showHpText,
-hpbonus,
1,
openEnded=0,
attackTrack=THROW_TRACK))
if revived != 0:
singleSuitResponseTrack.append(
MovieUtil.createSuitReviveTrack(suit, toon, battle))
else:
if died != 0:
singleSuitResponseTrack.append(
MovieUtil.createSuitDeathTrack(suit, toon, battle))
else:
if suit.isBoss:
singleSuitResponseTrack.append(
Func(suit.suitBoss.loop, 'Fb_downNeutral'))
else:
singleSuitResponseTrack.append(
Func(suit.loop, 'neutral'))
singleSuitResponseTrack = Parallel(singleSuitResponseTrack,
bonusTrack)
else:
groupHitValues = groupHitDict.values()
if groupHitValues.count(0) == len(groupHitValues):
singleSuitResponseTrack = MovieUtil.createSuitDodgeMultitrack(
delay + tSuitDodges, suit, leftSuits, rightSuits)
else:
singleSuitResponseTrack = Sequence(
Wait(tPieHitsSuit - 0.1),
Func(MovieUtil.indicateMissed, suit, 1.0))
groupSuitResponseTrack.append(singleSuitResponseTrack)
return [toonTrack, pieTrack, soundTrack, groupSuitResponseTrack]
def __createFishingPoleMultiTrack(lure, dollar, dollarName):
toon = lure['toon']
target = lure['target']
battle = lure['battle']
sidestep = lure['sidestep']
hp = target['hp']
kbbonus = target['kbbonus']
suit = target['suit']
targetPos = suit.getPos(battle)
died = target['died']
reachAnimDuration = 3.5
trapProp = suit.battleTrapProp
pole = globalPropPool.getProp('fishing-pole')
pole2 = MovieUtil.copyProp(pole)
poles = [pole, pole2]
hands = toon.getRightHands()
def positionDollar(dollar, suit):
dollar.reparentTo(suit)
dollar.setPos(0, MovieUtil.SUIT_LURE_DOLLAR_DISTANCE, 0)
dollarIvals = []
dollarIvals.append(
FunctionInterval(positionDollar, extraArgs=[dollar, suit]))
dollarAnims = []
dollarAnims.append(
FunctionInterval(dollar.wrtReparentTo, extraArgs=[battle]))
dollarAnims.append(ActorInterval(dollar, dollarName, duration=3))
dollarAnims.extend(
getSplicedLerpAnims(dollar, dollarName, 0.7, 2.0, startTime=3))
dollarAnims.append(LerpPosInterval(dollar, 0.2, Point3(0, -10, 7)))
dollarIvals.extend(dollarAnims)
dollarIvals.append(
FunctionInterval(MovieUtil.removeProp, extraArgs=[dollar]))
dollarTrack = Track(dollarIvals)
poleIvals = []
poleIvals.append(
FunctionInterval(MovieUtil.showProps, extraArgs=[poles, hands]))
poleIvals.append(ActorInterval(pole, 'fishing-pole'))
poleIvals.append(FunctionInterval(MovieUtil.removeProps,
extraArgs=[poles]))
poleTrack = Track(poleIvals)
toonTrack = Track([
FunctionInterval(toon.headsUp, extraArgs=[battle, targetPos]),
ActorInterval(toon, 'cast'),
FunctionInterval(toon.loop, extraArgs=['neutral'])
])
tracks = [dollarTrack, poleTrack, toonTrack]
if sidestep == 0:
if kbbonus == 1 or hp > 0:
suitIvals = []
opos, ohpr = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
suitIvals.append(FunctionInterval(suit.loop,
extraArgs=['neutral']))
suitIvals.append(WaitInterval(3.5))
suitName = suit.getStyleName()
retardPos, retardHpr = battle.getActorPosHpr(suit)
retardPos.setY(retardPos.getY() +
MovieUtil.SUIT_EXTRA_REACH_DISTANCE)
if suitName in MovieUtil.largeSuits:
moveTrack = lerpSuit(suit, 0.0, reachAnimDuration / 2.5,
retardPos, battle, trapProp)
reachTrack = Track(
[ActorInterval(suit, 'reach', duration=reachAnimDuration)])
suitIvals.append(MultiTrack([moveTrack, reachTrack]))
else:
suitIvals.append(
ActorInterval(suit, 'reach', duration=reachAnimDuration))
if trapProp:
suitIvals.append(
FunctionInterval(trapProp.wrtReparentTo,
extraArgs=[battle]))
suitIvals.append(
FunctionInterval(suit.setPos, extraArgs=[battle, reachPos]))
if trapProp:
suitIvals.append(
FunctionInterval(trapProp.wrtReparentTo, extraArgs=[suit]))
suit.battleTrapProp = trapProp
suitIvals.append(FunctionInterval(suit.loop,
extraArgs=['neutral']))
suitIvals.append(
FunctionInterval(battle.lureSuit, extraArgs=[suit]))
if hp > 0:
suitIvals.append(
__createSuitDamageTrack(battle, suit, hp, lure, trapProp))
if died != 0:
suitIvals.append(
MovieUtil.createSuitDeathTrack(suit, toon, battle))
tracks.append(Track(suitIvals))
else:
tracks.append(
Track([(3.7,
FunctionInterval(MovieUtil.indicateMissed,
extraArgs=[suit]))]))
tracks.append(getSoundTrack('TL_fishing_pole.mp3', delay=0.5, node=toon))
return MultiTrack(tracks)
def __doBugle(sound, delay, toon, targets, level):
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax = Vec3(0.4, 0.4, 0.4)
instrMax *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.5, 0.5, 0.5)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
instrument = globalPropPool.getProp('bugle')
instrument2 = MovieUtil.copyProp(instrument)
instruments = [instrument, instrument2]
def setInstrumentStats(instrument=instrument, instrument2=instrument2):
instrument.setPos(-1.3, -1.4, 0.1)
instrument.setHpr(145, 0, 85)
instrument.setScale(instrMin)
instrument2.setPos(-1.3, -1.4, 0.1)
instrument2.setHpr(145, 0, 85)
instrument2.setScale(instrMin)
def longshake(models, num):
inShake = getScaleBlendIntervals(models,
duration=0.2,
startScale=instrMax,
endScale=instrStretch,
blendType='easeInOut')
outShake = getScaleBlendIntervals(models,
duration=0.2,
startScale=instrStretch,
endScale=instrMax,
blendType='easeInOut')
i = 1
seq = Sequence()
while i < num:
if i % 2 == 0:
seq.append(inShake)
else:
seq.append(outShake)
i += 1
seq.start()
hands = toon.getRightHands()
megaphoneShow = Sequence(Func(MovieUtil.showProps, megaphones, hands),
Func(MovieUtil.showProps, instruments, hands),
Func(setInstrumentStats))
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones),
Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(
appearSoundFiles[level])
grow = getScaleBlendIntervals(instruments,
duration=1,
startScale=instrMin,
endScale=instrMax,
blendType='easeInOut')
instrumentshrink = getScaleIntervals(instruments,
duration=0.1,
startScale=instrMax,
endScale=instrMin)
instrumentAppear = Sequence(grow, Wait(0), Func(longshake, instruments, 5))
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
megaphoneTrack = Parallel(
Sequence(Wait(delay + 1.7), SoundInterval(soundEffect, node=toon)),
Sequence(Wait(delayTime), megaphoneShow, Wait(1.7), instrumentAppear,
Wait(1), instrumentshrink, Wait(1.5), megaphoneHide))
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound, delay, toon)
tracks.append(toonTrack)
if soundEffect:
delayTime = delay + tSound
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Wait(delayTime)
tracks.append(soundTrack)
return tracks
def __createMagnetMultiTrack(lure,
magnet,
pos,
hpr,
scale,
isSmallMagnet=1,
npcs=[]):
toon = lure['toon']
if 'npc' in lure:
toon = lure['npc']
battle = lure['battle']
sidestep = lure['sidestep']
targets = lure['target']
tracks = Parallel()
tracks.append(
Sequence(ActorInterval(toon, 'hold-magnet'),
Func(toon.loop, 'neutral')))
hands = toon.getLeftHands()
magnet2 = MovieUtil.copyProp(magnet)
magnets = [magnet, magnet2]
magnetTrack = Sequence(
Wait(0.7), Func(MovieUtil.showProps, magnets, hands, pos, hpr, scale),
Wait(6.3), Func(MovieUtil.removeProps, magnets))
tracks.append(magnetTrack)
for target in targets:
suit = target['suit']
trapProp = suit.battleTrapProp
if sidestep == 0:
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
if kbbonus == 1 or hp > 0:
suitDelay = 2.6
suitMoveDuration = 0.8
suitTrack = Sequence()
opos, ohpr = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
numShakes = 3
shakeTotalDuration = 0.8
shakeDuration = shakeTotalDuration / float(numShakes)
suitTrack.append(Func(suit.loop, 'neutral'))
suitTrack.append(Wait(suitDelay))
suitTrack.append(
ActorInterval(suit,
'landing',
startTime=2.37,
endTime=1.82))
for i in range(0, numShakes):
suitTrack.append(
ActorInterval(suit,
'landing',
startTime=1.82,
endTime=1.16,
duration=shakeDuration))
suitTrack.append(
ActorInterval(suit, 'landing', startTime=1.16,
endTime=0.7))
suitTrack.append(
ActorInterval(suit, 'landing', startTime=0.7,
duration=1.3))
suitTrack.append(Func(suit.loop, 'lured'))
suitTrack.append(Func(battle.lureSuit, suit))
if hp > 0:
suitTrack.append(
__createSuitDamageTrack(battle, suit, hp, lure,
trapProp))
if revived != 0:
suitTrack.append(
MovieUtil.createSuitReviveTrack(
suit, toon, battle, npcs))
elif died != 0:
suitTrack.append(
MovieUtil.createSuitDeathTrack(suit, toon, battle,
npcs))
tracks.append(suitTrack)
tracks.append(
lerpSuit(suit, suitDelay + 0.55 + shakeTotalDuration,
suitMoveDuration, reachPos, battle, trapProp))
else:
tracks.append(
Sequence(Wait(3.7), Func(MovieUtil.indicateMissed, suit)))
if isSmallMagnet == 1:
tracks.append(
getSoundTrack('TL_small_magnet.ogg', delay=0.7, node=toon))
else:
tracks.append(
getSoundTrack('TL_large_magnet.ogg', delay=0.7, node=toon))
return tracks
def __doOpera(sound, delay, toon, targets, level):
tracks = Parallel()
delay = delay
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(1.7, 1.7, 1.7)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(2.2, 2.2, 2.2)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.4, 0.4, 0.4)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
megaphone = globalPropPool.getProp('megaphone')
megaphone2 = MovieUtil.copyProp(megaphone)
megaphones = [megaphone, megaphone2]
instrument = globalPropPool.getProp('singing')
instrument2 = MovieUtil.copyProp(instrument)
instruments = [instrument, instrument2]
head = instrument2.find('**/opera_singer')
head.setPos(0, 0, 0)
def setInstrumentStats(instrument=instrument, instrument2=instrument2):
notify.debug('setInstrumentStats')
newPos = Vec3(-0.8, -0.9, 0.2)
newPos *= 1.3
instrument.setPos(newPos[0], newPos[1], newPos[2])
instrument.setHpr(145, 0, 90)
instrument.setScale(instrMin)
instrument2.setPos(newPos[0], newPos[1], newPos[2])
instrument2.setHpr(145, 0, 90)
instrument2.setScale(instrMin)
hands = toon.getRightHands()
megaphoneShow = Sequence(Func(MovieUtil.showProps, megaphones, hands),
Func(MovieUtil.showProps, instruments, hands),
Func(setInstrumentStats))
megaphoneHide = Sequence(Func(MovieUtil.removeProps, megaphones),
Func(MovieUtil.removeProps, instruments))
instrumentAppearSfx = globalBattleSoundCache.getSound(
appearSoundFiles[level])
grow1 = getScaleBlendIntervals(instruments,
duration=1,
startScale=instrMin,
endScale=instrMax1,
blendType='easeOut')
grow2 = getScaleBlendIntervals(instruments,
duration=1.1,
startScale=instrMax1,
endScale=instrMax2,
blendType='easeIn')
shrink2 = getScaleIntervals(instruments,
duration=0.1,
startScale=instrMax2,
endScale=instrMin)
instrumentAppear = Parallel(
Sequence(grow1, grow2, Wait(6.0), shrink2),
Sequence(Wait(0.0), SoundInterval(instrumentAppearSfx, node=toon)))
hasLuredSuits = __hasLuredSuits(sound)
delayTime = delay
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
megaphoneTrack = Sequence(Wait(delayTime), megaphoneShow, Wait(1.0),
instrumentAppear, Wait(2.0), megaphoneHide)
tracks.append(megaphoneTrack)
toonTrack = __createToonInterval(sound,
delay,
toon,
operaInstrument=instrument)
tracks.append(toonTrack)
soundEffect = globalBattleSoundCache.getSound(soundFiles[level])
if soundEffect:
delayTime = delay + tSound - 0.3
if hasLuredSuits:
delayTime += TIME_TO_WALK_BACK
soundTrack = Sequence(Wait(delayTime),
SoundInterval(soundEffect, node=toon))
tracks.append(Sequence(Wait(0)))
tracks.append(soundTrack)
return tracks
def __createHypnoGogglesMultiTrack(lure, npcs=[]):
toon = lure['toon']
if 'npc' in lure:
toon = lure['npc']
targets = lure['target']
battle = lure['battle']
sidestep = lure['sidestep']
goggles = globalPropPool.getProp('hypno-goggles')
goggles2 = MovieUtil.copyProp(goggles)
bothGoggles = [goggles, goggles2]
pos = Point3(-1.03, 1.04, -0.3)
hpr = Point3(-96.55, 36.14, -170.59)
scale = Point3(1.5, 1.5, 1.5)
hands = toon.getLeftHands()
gogglesTrack = Sequence(
Wait(0.6),
Func(MovieUtil.showProps, bothGoggles, hands, pos, hpr, scale),
ActorInterval(goggles, 'hypno-goggles', duration=2.2),
Func(MovieUtil.removeProps, bothGoggles))
toonTrack = Sequence(ActorInterval(toon, 'hypnotize'),
Func(toon.loop, 'neutral'))
tracks = Parallel(gogglesTrack, toonTrack)
for target in targets:
suit = target['suit']
trapProp = suit.battleTrapProp
if sidestep == 0:
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
if kbbonus == 1 or hp > 0:
suitTrack = Sequence()
suitDelay = 1.6
suitAnimDuration = 1.5
opos, ohpr = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
suitTrack.append(Func(suit.loop, 'neutral'))
suitTrack.append(Wait(suitDelay))
suitTrack.append(
ActorInterval(suit, 'hypnotized', duration=3.1))
suitTrack.append(Func(suit.setPos, battle, reachPos))
suitTrack.append(Func(suit.loop, 'lured'))
suitTrack.append(Func(battle.lureSuit, suit))
if hp > 0:
suitTrack.append(
__createSuitDamageTrack(battle, suit, hp, lure,
trapProp))
if revived != 0:
suitTrack.append(
MovieUtil.createSuitReviveTrack(
suit, toon, battle, npcs))
elif died != 0:
suitTrack.append(
MovieUtil.createSuitDeathTrack(suit, toon, battle,
npcs))
tracks.append(suitTrack)
tracks.append(
lerpSuit(suit, suitDelay + 1.7, 0.7, reachPos, battle,
trapProp))
else:
tracks.append(
Sequence(Wait(2.3), Func(MovieUtil.indicateMissed, suit, 1.1)))
tracks.append(getSoundTrack('TL_hypnotize.ogg', delay=0.5, node=toon))
return tracks
def doTraps(traps):
if len(traps) == 0:
return (None, None)
npcArrivals, npcDepartures, npcs = MovieNPCSOS.doNPCTeleports(traps)
hasUberTrapConflict = False
suitTrapsDict = {}
for trap in traps:
targets = trap['target']
if len(targets) == 1:
suitId = targets[0]['suit'].doId
if suitTrapsDict.has_key(suitId):
suitTrapsDict[suitId].append(trap)
else:
suitTrapsDict[suitId] = [
trap]
else:
for target in targets:
suitId = target['suit'].doId
if not suitTrapsDict.has_key(suitId):
suitTrapsDict[suitId] = [
trap]
break
if trap['level'] == UBER_GAG_LEVEL_INDEX:
if len(traps) > 1:
hasUberTrapConflict = True
for oneTarget in trap['target']:
suit = oneTarget['suit']
if suit.battleTrap != NO_TRAP:
hasUberTrapConflict = True
suitTrapLists = suitTrapsDict.values()
mtrack = Parallel()
for trapList in suitTrapLists:
trapPropList = []
for i in range(len(trapList)):
trap = trapList[i]
level = trap['level']
if level == 0:
banana = globalPropPool.getProp('banana')
banana2 = MovieUtil.copyProp(banana)
trapPropList.append([banana, banana2])
elif level == 1:
rake = globalPropPool.getProp('rake')
rake2 = MovieUtil.copyProp(rake)
rake.pose('rake', 0)
rake2.pose('rake', 0)
trapPropList.append([rake, rake2])
elif level == 2:
marbles = globalPropPool.getProp('marbles')
marbles2 = MovieUtil.copyProp(marbles)
trapPropList.append([marbles, marbles2])
elif level == 3:
trapPropList.append([globalPropPool.getProp('quicksand')])
elif level == 4:
trapPropList.append([globalPropPool.getProp('trapdoor')])
elif level == 5:
tnt = globalPropPool.getProp('tnt')
tnt2 = MovieUtil.copyProp(tnt)
trapPropList.append([tnt, tnt2])
elif level == 6:
tnt = globalPropPool.getProp('traintrack')
tnt2 = MovieUtil.copyProp(tnt)
trapPropList.append([tnt, tnt2])
else:
notify.warning('__doTraps() - Incorrect trap level: %d' % level)
if len(trapList) == 1 and not hasUberTrapConflict:
ival = __doTrapLevel(trapList[0], trapPropList[0])
if ival:
mtrack.append(ival)
else:
subMtrack = Parallel()
for i in range(len(trapList)):
trap = trapList[i]
trapProps = trapPropList[i]
ival = __doTrapLevel(trap, trapProps, explode=1)
if ival:
subMtrack.append(ival)
mtrack.append(subMtrack)
trapTrack = Sequence(npcArrivals, mtrack, npcDepartures)
camDuration = mtrack.getDuration()
enterDuration = npcArrivals.getDuration()
exitDuration = npcDepartures.getDuration()
camTrack = MovieCamera.chooseTrapShot(traps, camDuration, enterDuration, exitDuration)
return (
trapTrack, camTrack)
def __createFishingPoleMultiTrack(lure, dollar, dollarName):
toon = lure['toon']
target = lure['target']
battle = lure['battle']
sidestep = lure['sidestep']
hp = target['hp']
kbbonus = target['kbbonus']
suit = target['suit']
targetPos = suit.getPos(battle)
died = target['died']
revived = target['revived']
reachAnimDuration = 3.5
trapProp = suit.battleTrapProp
pole = globalPropPool.getProp('fishing-pole')
pole2 = MovieUtil.copyProp(pole)
poles = [pole, pole2]
hands = toon.getRightHands()
def positionDollar(dollar, suit):
dollar.reparentTo(suit)
dollar.setPos(0, MovieUtil.SUIT_LURE_DOLLAR_DISTANCE, 0)
dollarTrack = Sequence(
Func(positionDollar, dollar, suit), Func(dollar.wrtReparentTo, battle),
ActorInterval(dollar, dollarName, duration=3),
getSplicedLerpAnimsTrack(dollar, dollarName, 0.7, 2.0, startTime=3),
LerpPosInterval(dollar, 0.2, Point3(0, -10, 7)),
Func(MovieUtil.removeProp, dollar))
poleTrack = Sequence(Func(MovieUtil.showProps, poles, hands),
ActorInterval(pole, 'fishing-pole'),
Func(MovieUtil.removeProps, poles))
toonTrack = Sequence(Func(toon.headsUp, battle, targetPos),
ActorInterval(toon, 'battlecast'),
Func(toon.loop, 'neutral'))
tracks = Parallel(dollarTrack, poleTrack, toonTrack)
if sidestep == 0:
if kbbonus == 1 or hp > 0:
suitTrack = Sequence()
opos, ohpr = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
suitTrack.append(Func(suit.loop, 'neutral'))
suitTrack.append(Wait(3.5))
suitName = suit.getStyleName()
retardPos, retardHpr = battle.getActorPosHpr(suit)
retardPos.setY(retardPos.getY() +
MovieUtil.SUIT_EXTRA_REACH_DISTANCE)
if suitName in MovieUtil.largeSuits:
moveTrack = lerpSuit(suit, 0.0, reachAnimDuration / 2.5,
retardPos, battle, trapProp)
reachTrack = ActorInterval(suit,
'reach',
duration=reachAnimDuration)
suitTrack.append(Parallel(moveTrack, reachTrack))
else:
suitTrack.append(
ActorInterval(suit, 'reach', duration=reachAnimDuration))
if trapProp:
suitTrack.append(Func(trapProp.wrtReparentTo, battle))
suitTrack.append(Func(suit.setPos, battle, reachPos))
if trapProp:
suitTrack.append(Func(trapProp.wrtReparentTo, suit))
suit.battleTrapProp = trapProp
suitTrack.append(Func(suit.loop, 'lured'))
suitTrack.append(Func(battle.lureSuit, suit))
if hp > 0:
suitTrack.append(
__createSuitDamageTrack(battle, suit, hp, lure, trapProp))
if revived != 0:
suitTrack.append(
MovieUtil.createSuitReviveTrack(suit, toon, battle))
if died != 0:
suitTrack.append(
MovieUtil.createSuitDeathTrack(suit, toon, battle))
tracks.append(suitTrack)
else:
tracks.append(Sequence(Wait(3.7), Func(MovieUtil.indicateMissed,
suit)))
tracks.append(getSoundTrack('TL_fishing_pole.ogg', delay=0.5, node=toon))
return tracks
def __createPlacedTrapMultiTrack(trap, prop, propName, propPos=None, propHpr=None, explode=0, visibleOnlyForThisSuitId=None):
toon = trap['toon']
if trap.has_key('npc'):
toon = trap['npc']
level = trap['level']
battle = trap['battle']
origHpr = toon.getHpr(battle)
trapPoint = Point3(0, MovieUtil.SUIT_TRAP_DISTANCE, 0.025)
trapDelay = 2.5
if toon.isDisguised:
hands = toon.suit.getLeftHands()
else:
hands = toon.getLeftHands()
def placeDustExplosion(dustNode, trapProp, battle):
dustNode.reparentTo(battle)
dustNode.setPos(trapProp.getPos(battle))
trapTracks = Parallel()
firstTime = 1
targets = trap['target']
for target in targets:
suit = target['suit']
suitPos = suit.getPos(battle)
targetPos = suitPos
trapProp = MovieUtil.copyProp(prop)
showThisTrap = True
if visibleOnlyForThisSuitId and visibleOnlyForThisSuitId != suit.doId:
showThisTrap = False
trapTrack = Sequence()
trapTrack.append(Wait(trapDelay))
if showThisTrap:
notify.debug('showing trap %s for %d' % (trapProp.getName(), suit.doId))
trapTrack.append(Func(trapProp.show))
else:
notify.debug('hiding trap %s for %d' % (trapProp.getName(), suit.doId))
trapTrack.append(Func(trapProp.hide))
trapTrack.append(Func(trapProp.setScale, Point3(0.1, 0.1, 0.1)))
trapTrack.append(Func(trapProp.reparentTo, suit))
trapTrack.append(Func(trapProp.setPos, trapPoint))
trapTrack.append(LerpScaleInterval(trapProp, 1.2, Point3(1.7, 1.7, 1.7)))
if explode == 1:
dustNode = hidden.attachNewNode('DustNode')
trapTrack.append(Func(trapProp.wrtReparentTo, hidden))
trapTrack.append(Func(placeDustExplosion, dustNode, trapProp, battle))
trapTrack.append(createCartoonExplosionTrack(dustNode, 'dust', explosionPoint=Point3(0, 0, 0)))
trapTrack.append(Func(MovieUtil.removeProp, trapProp))
trapTrack.append(Func(battle.removeTrap, suit))
else:
if suit.battleTrap != NO_TRAP:
notify.debug('trapSuit() - trap: %d destroyed existing trap: %d' % (level, suit.battleTrap))
battle.removeTrap(suit)
suit.battleTrapProp = trapProp
suit.battleTrap = level
suit.battleTrapIsFresh = 1
trapTracks.append(trapTrack)
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
if toon.isDisguised:
for b in buttons:
b.setP(180)
toonTrack = Sequence()
toonTrack.append(Func(MovieUtil.showProps, buttons, hands))
toonTrack.append(Func(toon.headsUp, battle, suitPos))
if toon.isDisguised:
if toon.suit.style.body == 'c':
toonTrack.append(Func(toon.suit.pose, 'phone', 0))
if toon.suit.style.body == 'a':
toonTrack.append(Sequence(Wait(1), ActorInterval(toon.suit, 'phone', endFrame=26, playRate=0.8), ActorInterval(toon.suit, 'phone', startFrame=26, endFrame=0)))
elif toon.suit.style.body == 'b':
toonTrack.append(Sequence(Wait(1), ActorInterval(toon.suit, 'phone', endFrame=32), ActorInterval(toon.suit, 'phone', startFrame=32, endFrame=0)))
else:
toonTrack.append(Sequence(Wait(1), ActorInterval(toon.suit, 'phone', endFrame=29), ActorInterval(toon.suit, 'phone', startFrame=29, endFrame=0)))
else:
toonTrack.append(ActorInterval(toon, 'pushbutton'))
toonTrack.append(Func(MovieUtil.removeProps, buttons))
if toon.isDisguised:
toonTrack.append(Func(toon.suit.loop, 'neutral'))
else:
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
if propName == 'quicksand':
propSound = globalBattleSoundCache.getSound('TL_quicksand.ogg')
else:
propSound = globalBattleSoundCache.getSound('TL_trap_door.ogg')
buttonSound = globalBattleSoundCache.getSound('AA_drop_trigger_box.ogg')
soundTrack = Sequence(Wait(2.3), SoundInterval(buttonSound, duration=0.67, node=toon), Wait(0.3), SoundInterval(propSound, duration=0.5, node=toon))
return Parallel(trapTracks, toonTrack, soundTrack)
def __createSlideshowMultiTrack(lure, npcs=[]):
toon = lure['toon']
battle = lure['battle']
sidestep = lure['sidestep']
origHpr = toon.getHpr(battle)
slideshowDelay = 2.5
hands = toon.getLeftHands()
endPos = toon.getPos(battle)
endPos.setY(endPos.getY() + 4)
button = globalPropPool.getProp('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
toonTrack = Sequence()
toonTrack.append(Func(MovieUtil.showProps, buttons, hands))
toonTrack.append(Func(toon.headsUp, battle, endPos))
toonTrack.append(ActorInterval(toon, 'pushbutton'))
toonTrack.append(Func(MovieUtil.removeProps, buttons))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
slideShowProp = globalPropPool.getProp('slideshow')
propTrack = Sequence()
propTrack.append(Wait(slideshowDelay))
propTrack.append(Func(slideShowProp.show))
propTrack.append(Func(slideShowProp.setScale, Point3(0.1, 0.1, 0.1)))
propTrack.append(Func(slideShowProp.reparentTo, battle))
propTrack.append(Func(slideShowProp.setPos, endPos))
propTrack.append(
LerpScaleInterval(slideShowProp, 1.2, Point3(1.0, 1.0, 1.0)))
shrinkDuration = 0.4
totalDuration = 7.1
propTrackDurationAtThisPoint = propTrack.getDuration()
waitTime = totalDuration - propTrackDurationAtThisPoint - shrinkDuration
if waitTime > 0:
propTrack.append(Wait(waitTime))
propTrack.append(
LerpScaleInterval(nodePath=slideShowProp,
scale=Point3(1.0, 1.0, 0.1),
duration=shrinkDuration))
propTrack.append(Func(MovieUtil.removeProp, slideShowProp))
tracks = Parallel(propTrack, toonTrack)
targets = lure['target']
for target in targets:
suit = target['suit']
trapProp = suit.battleTrapProp
if sidestep == 0:
hp = target['hp']
kbbonus = target['kbbonus']
died = target['died']
revived = target['revived']
if kbbonus == 1 or hp > 0:
suitTrack = Sequence()
suitDelay = 3.8
suitAnimDuration = 1.5
opos, ohpr = battle.getActorPosHpr(suit)
reachDist = MovieUtil.SUIT_LURE_DISTANCE
reachPos = Point3(opos[0], opos[1] - reachDist, opos[2])
suitTrack.append(Func(suit.loop, 'neutral'))
suitTrack.append(Wait(suitDelay))
suitTrack.append(
ActorInterval(suit, 'hypnotized', duration=3.1))
suitTrack.append(Func(suit.setPos, battle, reachPos))
suitTrack.append(Func(suit.loop, 'lured'))
suitTrack.append(Func(battle.lureSuit, suit))
if hp > 0:
suitTrack.append(
__createSuitDamageTrack(battle, suit, hp, lure,
trapProp))
if revived != 0:
suitTrack.append(
MovieUtil.createSuitReviveTrack(
suit, toon, battle, npcs))
elif died != 0:
suitTrack.append(
MovieUtil.createSuitDeathTrack(suit, toon, battle,
npcs))
tracks.append(suitTrack)
tracks.append(
lerpSuit(suit, suitDelay + 1.7, 0.7, reachPos, battle,
trapProp))
else:
tracks.append(
Sequence(Wait(2.3), Func(MovieUtil.indicateMissed, suit, 1.1)))
tracks.append(getSoundTrack('TL_presentation.ogg', delay=2.3, node=toon))
tracks.append(
getSoundTrack('AA_drop_trigger_box.ogg',
delay=slideshowDelay,
node=toon))
return tracks
def __throwPie(throw, delay, hitCount, showCannon = 1):
toon = throw['toon']
hpbonus = throw['hpbonus']
target = throw['target']
suit = target['suit']
hp = target['hp']
kbbonus = target['kbbonus']
sidestep = throw['sidestep']
died = target['died']
revived = target['revived']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
level = throw['level']
battle = throw['battle']
suitPos = suit.getPos(battle)
origHpr = toon.getHpr(battle)
notify.debug('toon: %s throws tart at suit: %d for hp: %d died: %d' % (toon.getName(),
suit.doId,
hp,
died))
pieName = pieNames[0]
hitSuit = hp > 0
button = globalPropPool.getProp('button')
buttonType = globalPropPool.getPropType('button')
button2 = MovieUtil.copyProp(button)
buttons = [button, button2]
hands = toon.getLeftHands()
toonTrack = Sequence()
toonFace = Func(toon.headsUp, battle, suitPos)
toonTrack.append(Wait(delay))
toonTrack.append(toonFace)
toonTrack.append(ActorInterval(toon, 'pushbutton'))
toonTrack.append(ActorInterval(toon, 'wave', duration=2.0))
toonTrack.append(ActorInterval(toon, 'duck'))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
buttonTrack = Sequence()
buttonShow = Func(MovieUtil.showProps, buttons, hands)
buttonScaleUp = LerpScaleInterval(button, 1.0, button.getScale(), startScale=Point3(0.01, 0.01, 0.01))
buttonScaleDown = LerpScaleInterval(button, 1.0, Point3(0.01, 0.01, 0.01), startScale=button.getScale())
buttonHide = Func(MovieUtil.removeProps, buttons)
buttonTrack.append(Wait(delay))
buttonTrack.append(buttonShow)
buttonTrack.append(buttonScaleUp)
buttonTrack.append(Wait(2.5))
buttonTrack.append(buttonScaleDown)
buttonTrack.append(buttonHide)
soundTrack = __getSoundTrack(level, hitSuit, toon)
suitResponseTrack = Sequence()
reactIval = Sequence()
if showCannon:
showDamage = Func(suit.showHpText, -hp, openEnded=0)
updateHealthBar = Func(suit.updateHealthBar, hp)
cannon = loader.loadModel('phase_4/models/minigames/toon_cannon')
barrel = cannon.find('**/cannon')
barrel.setHpr(0, 90, 0)
cannonHolder = render.attachNewNode('CannonHolder')
cannon.reparentTo(cannonHolder)
cannon.setPos(0, 0, -8.6)
cannonHolder.setPos(suit.getPos(render))
cannonHolder.setHpr(suit.getHpr(render))
cannonAttachPoint = barrel.attachNewNode('CannonAttach')
kapowAttachPoint = barrel.attachNewNode('kapowAttach')
scaleFactor = 1.6
iScale = 1 / scaleFactor
barrel.setScale(scaleFactor, 1, scaleFactor)
cannonAttachPoint.setScale(iScale, 1, iScale)
cannonAttachPoint.setPos(0, 6.7, 0)
kapowAttachPoint.setPos(0, -0.5, 1.9)
suit.reparentTo(cannonAttachPoint)
suit.setPos(0, 0, 0)
suit.setHpr(0, -90, 0)
suitLevel = suit.getActualLevel()
deep = 2.5 + suitLevel * 0.2
suitScale = 0.9
import math
suitScale = 0.9 - math.sqrt(suitLevel) * 0.1
sival = []
posInit = cannonHolder.getPos()
posFinal = Point3(posInit[0] + 0.0, posInit[1] + 0.0, posInit[2] + 7.0)
kapow = globalPropPool.getProp('kapow')
kapow.reparentTo(kapowAttachPoint)
kapow.hide()
kapow.setScale(0.25)
kapow.setBillboardPointEye()
smoke = loader.loadModel('phase_4/models/props/test_clouds')
smoke.reparentTo(cannonAttachPoint)
smoke.setScale(0.5)
smoke.hide()
smoke.setBillboardPointEye()
soundBomb = base.loadSfx('phase_4/audio/sfx/MG_cannon_fire_alt.ogg')
playSoundBomb = SoundInterval(soundBomb, node=cannonHolder)
soundFly = base.loadSfx('phase_4/audio/sfx/firework_whistle_01.ogg')
playSoundFly = SoundInterval(soundFly, node=cannonHolder)
soundCannonAdjust = base.loadSfx('phase_4/audio/sfx/MG_cannon_adjust.ogg')
playSoundCannonAdjust = SoundInterval(soundCannonAdjust, duration=0.6, node=cannonHolder)
soundCogPanic = base.loadSfx('phase_5/audio/sfx/ENC_cogafssm.ogg')
playSoundCogPanic = SoundInterval(soundCogPanic, node=cannonHolder)
reactIval = Parallel(ActorInterval(suit, 'pie-small-react'), Sequence(Wait(0.0), LerpPosInterval(cannonHolder, 2.0, posFinal, startPos=posInit, blendType='easeInOut'), Parallel(LerpHprInterval(barrel, 0.6, Point3(0, 45, 0), startHpr=Point3(0, 90, 0), blendType='easeIn'), playSoundCannonAdjust), Wait(2.0), Parallel(LerpHprInterval(barrel, 0.6, Point3(0, 90, 0), startHpr=Point3(0, 45, 0), blendType='easeIn'), playSoundCannonAdjust), LerpPosInterval(cannonHolder, 1.0, posInit, startPos=posFinal, blendType='easeInOut')), Sequence(Wait(0.0), Parallel(ActorInterval(suit, 'flail'), suit.scaleInterval(1.0, suitScale), LerpPosInterval(suit, 0.25, Point3(0, -1.0, 0.0)), Sequence(Wait(0.25), Parallel(playSoundCogPanic, LerpPosInterval(suit, 1.5, Point3(0, -deep, 0.0), blendType='easeIn')))), Wait(2.5), Parallel(playSoundBomb, playSoundFly, Sequence(Func(smoke.show), Parallel(LerpScaleInterval(smoke, 0.5, 3), LerpColorScaleInterval(smoke, 0.5, Vec4(2, 2, 2, 0))), Func(smoke.hide)), Sequence(Func(kapow.show),
ActorInterval(kapow, 'kapow'), Func(kapow.hide)), LerpPosInterval(suit, 3.0, Point3(0, 150.0, 0.0)), suit.scaleInterval(3.0, 0.01)), Func(suit.hide)))
if hitCount == 1:
sival = Sequence(Parallel(reactIval, MovieUtil.createSuitStunInterval(suit, 0.3, 1.3)), Wait(0.0), Func(cannonHolder.remove))
else:
sival = reactIval
suitResponseTrack.append(Wait(delay + tPieHitsSuit))
suitResponseTrack.append(showDamage)
suitResponseTrack.append(updateHealthBar)
suitResponseTrack.append(sival)
bonusTrack = Sequence(Wait(delay + tPieHitsSuit))
if kbbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(Func(suit.showHpText, -kbbonus, 2, openEnded=0))
if hpbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(Func(suit.showHpText, -hpbonus, 1, openEnded=0))
suitResponseTrack = Parallel(suitResponseTrack, bonusTrack)
return [toonTrack,
soundTrack,
buttonTrack,
suitResponseTrack]
def __throwPie(throw, delay, hitCount):
toon = throw['toon']
hpbonus = throw['hpbonus']
target = throw['target']
suit = target['suit']
hp = target['hp']
kbbonus = target['kbbonus']
sidestep = throw['sidestep']
died = target['died']
revived = target['revived']
leftSuits = target['leftSuits']
rightSuits = target['rightSuits']
level = throw['level']
battle = throw['battle']
suitPos = suit.getPos(battle)
origHpr = toon.getHpr(battle)
notify.debug('toon: %s throws tart at suit: %d for hp: %d died: %d' % (toon.getName(),
suit.doId,
hp,
died))
pieName = pieNames[level]
hitSuit = hp > 0
pie = globalPropPool.getProp(pieName)
pieType = globalPropPool.getPropType(pieName)
pie2 = MovieUtil.copyProp(pie)
pies = [pie, pie2]
hands = toon.getRightHands()
splatName = 'splat-' + pieName
if pieName == 'wedding-cake':
splatName = 'splat-birthday-cake'
splat = globalPropPool.getProp(splatName)
splatType = globalPropPool.getPropType(splatName)
toonTrack = Sequence()
toonFace = Func(toon.headsUp, battle, suitPos)
toonTrack.append(Wait(delay))
toonTrack.append(toonFace)
toonTrack.append(ActorInterval(toon, 'throw'))
toonTrack.append(Func(toon.loop, 'neutral'))
toonTrack.append(Func(toon.setHpr, battle, origHpr))
pieShow = Func(MovieUtil.showProps, pies, hands)
pieAnim = Func(__animProp, pies, pieName, pieType)
pieScale1 = LerpScaleInterval(pie, 1.0, pie.getScale(), startScale=MovieUtil.PNT3_NEARZERO)
pieScale2 = LerpScaleInterval(pie2, 1.0, pie2.getScale(), startScale=MovieUtil.PNT3_NEARZERO)
pieScale = Parallel(pieScale1, pieScale2)
piePreflight = Func(__propPreflight, pies, suit, toon, battle)
pieTrack = Sequence(Wait(delay), pieShow, pieAnim, pieScale, Func(battle.movie.needRestoreRenderProp, pies[0]), Wait(tPieLeavesHand - 1.0), piePreflight)
soundTrack = __getSoundTrack(level, hitSuit, toon)
if hitSuit:
pieFly = LerpPosInterval(pie, tPieHitsSuit - tPieLeavesHand, pos=MovieUtil.avatarFacePoint(suit, other=battle), name=pieFlyTaskName, other=battle)
pieHide = Func(MovieUtil.removeProps, pies)
splatShow = Func(__showProp, splat, suit, Point3(0, 0, suit.getHeight()))
splatBillboard = Func(__billboardProp, splat)
splatAnim = ActorInterval(splat, splatName)
splatHide = Func(MovieUtil.removeProp, splat)
pieTrack.append(pieFly)
pieTrack.append(pieHide)
pieTrack.append(Func(battle.movie.clearRenderProp, pies[0]))
pieTrack.append(splatShow)
pieTrack.append(splatBillboard)
pieTrack.append(splatAnim)
pieTrack.append(splatHide)
else:
missDict = {}
if sidestep:
suitPoint = MovieUtil.avatarFacePoint(suit, other=battle)
else:
suitPoint = __suitMissPoint(suit, other=battle)
piePreMiss = Func(__piePreMiss, missDict, pie, suitPoint, battle)
pieMiss = LerpFunctionInterval(__pieMissLerpCallback, extraArgs=[missDict], duration=(tPieHitsSuit - tPieLeavesHand) * ratioMissToHit)
pieHide = Func(MovieUtil.removeProps, pies)
pieTrack.append(piePreMiss)
pieTrack.append(pieMiss)
pieTrack.append(pieHide)
pieTrack.append(Func(battle.movie.clearRenderProp, pies[0]))
if hitSuit:
suitResponseTrack = Sequence()
showDamage = Func(suit.showHpText, -hp, openEnded=0, attackTrack=THROW_TRACK)
updateHealthBar = Func(suit.updateHealthBar, hp)
sival = []
if kbbonus > 0:
suitPos, suitHpr = battle.getActorPosHpr(suit)
suitType = getSuitBodyType(suit.getStyleName())
animTrack = Sequence()
animTrack.append(ActorInterval(suit, 'pie-small-react', duration=0.2))
if suitType == 'a':
animTrack.append(ActorInterval(suit, 'slip-forward', startTime=2.43))
elif suitType == 'b':
animTrack.append(ActorInterval(suit, 'slip-forward', startTime=1.94))
elif suitType == 'c':
animTrack.append(ActorInterval(suit, 'slip-forward', startTime=2.58))
animTrack.append(Func(battle.unlureSuit, suit))
moveTrack = Sequence(Wait(0.2), LerpPosInterval(suit, 0.6, pos=suitPos, other=battle))
sival = Parallel(animTrack, moveTrack)
elif hitCount == 1:
sival = Parallel(ActorInterval(suit, 'pie-small-react'), MovieUtil.createSuitStunInterval(suit, 0.3, 1.3))
else:
sival = ActorInterval(suit, 'pie-small-react')
suitResponseTrack.append(Wait(delay + tPieHitsSuit))
suitResponseTrack.append(showDamage)
suitResponseTrack.append(updateHealthBar)
suitResponseTrack.append(sival)
bonusTrack = Sequence(Wait(delay + tPieHitsSuit))
if kbbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(Func(suit.showHpText, -kbbonus, 2, openEnded=0, attackTrack=THROW_TRACK))
if hpbonus > 0:
bonusTrack.append(Wait(0.75))
bonusTrack.append(Func(suit.showHpText, -hpbonus, 1, openEnded=0, attackTrack=THROW_TRACK))
if revived != 0:
suitResponseTrack.append(MovieUtil.createSuitReviveTrack(suit, toon, battle))
elif died != 0:
suitResponseTrack.append(MovieUtil.createSuitDeathTrack(suit, toon, battle))
else:
suitResponseTrack.append(Func(suit.loop, 'neutral'))
suitResponseTrack = Parallel(suitResponseTrack, bonusTrack)
else:
suitResponseTrack = MovieUtil.createSuitDodgeMultitrack(delay + tSuitDodges, suit, leftSuits, rightSuits)
if not hitSuit and delay > 0:
return [toonTrack, soundTrack, pieTrack]
else:
return [toonTrack,
soundTrack,
pieTrack,
suitResponseTrack]
def doFanfare(delay, toon, panel):
fanfareNode = toon.attachNewNode('fanfareNode')
partyBall = fanfareNode.attachNewNode('partyBall')
headparts = toon.getHeadParts()
pos = headparts[2].getPos(fanfareNode)
partyBallLeft = globalPropPool.getProp('partyBall')
partyBallLeft.reparentTo(partyBall)
partyBallLeft.setScale(0.80000000000000004)
partyBallLeft.setH(90)
partyBallLeft.setColorScale(1, 0, 0, 0)
partyBallRight = globalPropPool.getProp('partyBall')
partyBallRight.reparentTo(partyBall)
partyBallRight.setScale(0.80000000000000004)
partyBallRight.setH(-90)
partyBallRight.setColorScale(1, 1, 0, 0)
partyBall.setZ(pos.getZ() + 3.2000000000000002)
ballShake1 = Sequence(Parallel(LerpHprInterval(partyBallLeft, duration = 0.20000000000000001, startHpr = Vec3(90, 0, 0), hpr = Vec3(90, 10, 0), blendType = 'easeInOut'), LerpHprInterval(partyBallRight, duration = 0.20000000000000001, startHpr = Vec3(-90, 0, 0), hpr = Vec3(-90, -10, 0), blendType = 'easeInOut')), Parallel(LerpHprInterval(partyBallLeft, duration = 0.20000000000000001, startHpr = Vec3(90, 10, 0), hpr = Vec3(90, -10, 0), blendType = 'easeInOut'), LerpHprInterval(partyBallRight, duration = 0.20000000000000001, startHpr = Vec3(-90, -10, 0), hpr = Vec3(-90, 10, 0), blendType = 'easeInOut')), Parallel(LerpHprInterval(partyBallLeft, duration = 0.20000000000000001, startHpr = Vec3(90, -10, 0), hpr = Vec3(90, 0, 0), blendType = 'easeInOut'), LerpHprInterval(partyBallRight, duration = 0.20000000000000001, startHpr = Vec3(-90, 10, 0), hpr = Vec3(-90, 0, 0), blendType = 'easeInOut')))
ballShake2 = Sequence(Parallel(LerpHprInterval(partyBallLeft, duration = 0.20000000000000001, startHpr = Vec3(90, 0, 0), hpr = Vec3(90, -10, 0), blendType = 'easeInOut'), LerpHprInterval(partyBallRight, duration = 0.20000000000000001, startHpr = Vec3(-90, 0, 0), hpr = Vec3(-90, 10, 0), blendType = 'easeInOut')), Parallel(LerpHprInterval(partyBallLeft, duration = 0.20000000000000001, startHpr = Vec3(90, -10, 0), hpr = Vec3(90, 10, 0), blendType = 'easeInOut'), LerpHprInterval(partyBallRight, duration = 0.20000000000000001, startHpr = Vec3(-90, 10, 0), hpr = Vec3(-90, -10, 0), blendType = 'easeInOut')), Parallel(LerpHprInterval(partyBallLeft, duration = 0.20000000000000001, startHpr = Vec3(90, 10, 0), hpr = Vec3(90, 0, 0), blendType = 'easeInOut'), LerpHprInterval(partyBallRight, duration = 0.20000000000000001, startHpr = Vec3(-90, -10, 0), hpr = Vec3(-90, 0, 0), blendType = 'easeInOut')))
openBall = Parallel(LerpHprInterval(partyBallLeft, duration = 0.20000000000000001, startHpr = Vec3(90, 0, 0), hpr = Vec3(90, 30, 0)), LerpHprInterval(partyBallRight, duration = 0.20000000000000001, startHpr = Vec3(-90, 0, 0), hpr = Vec3(-90, 30, 0)))
confettiNode = fanfareNode.attachNewNode('confetti')
confettiNode.setScale(3)
confettiNode.setZ(pos.getZ() + 2.5)
def longshake(models, num, duration):
inShake = getScaleBlendIntervals(models, duration = duration, startScale = 0.23000000000000001, endScale = 0.20000000000000001, blendType = 'easeInOut')
outShake = getScaleBlendIntervals(models, duration = duration, startScale = 0.20000000000000001, endScale = 0.23000000000000001, blendType = 'easeInOut')
i = 1
seq = Sequence()
while i < num:
if i % 2 == 0:
seq.append(inShake)
else:
seq.append(outShake)
i += 1
return seq
def getScaleBlendIntervals(props, duration, startScale, endScale, blendType):
tracks = Parallel()
for prop in props:
tracks.append(LerpScaleInterval(prop, duration, endScale, startScale = startScale, blendType = blendType))
return tracks
trumpetNode = fanfareNode.attachNewNode('trumpetNode')
trumpet1 = globalPropPool.getProp('bugle')
trumpet2 = MovieUtil.copyProp(trumpet1)
trumpet1.reparentTo(trumpetNode)
trumpet1.setScale(0.20000000000000001)
trumpet1.setPos(2, 2, 1)
trumpet1.setHpr(120, 65, 0)
trumpet2.reparentTo(trumpetNode)
trumpet2.setScale(0.20000000000000001)
trumpet2.setPos(-2, 2, 1)
trumpet2.setHpr(-120, 65, 0)
trumpetNode.setTransparency(1)
trumpetNode.setColor(1, 1, 1, 0)
trumpturn1 = LerpHprInterval(trumpet1, duration = 4, startHpr = Vec3(80, 15, 0), hpr = Vec3(150, 40, 0))
trumpturn2 = LerpHprInterval(trumpet2, duration = 4, startHpr = Vec3(-80, 15, 0), hpr = Vec3(-150, 40, 0))
trumpetTurn = Parallel(trumpturn1, trumpturn2)
BattleParticles.loadParticles()
confettiBlue = BattleParticles.createParticleEffect('Confetti')
confettiBlue.reparentTo(confettiNode)
blue_p0 = confettiBlue.getParticlesNamed('particles-1')
blue_p0.renderer.getColorInterpolationManager().addConstant(0.0, 1.0, Vec4(0.0, 0.0, 1.0, 1.0), 1)
confettiYellow = BattleParticles.createParticleEffect('Confetti')
confettiYellow.reparentTo(confettiNode)
yellow_p0 = confettiYellow.getParticlesNamed('particles-1')
yellow_p0.renderer.getColorInterpolationManager().addConstant(0.0, 1.0, Vec4(1.0, 1.0, 0.0, 1.0), 1)
confettiRed = BattleParticles.createParticleEffect('Confetti')
confettiRed.reparentTo(confettiNode)
red_p0 = confettiRed.getParticlesNamed('particles-1')
red_p0.renderer.getColorInterpolationManager().addConstant(0.0, 1.0, Vec4(1.0, 0.0, 0.0, 1.0), 1)
trumpetsAppear = LerpColorInterval(trumpetNode, 0.29999999999999999, startColor = Vec4(1, 1, 0, 0), color = Vec4(1, 1, 0, 1))
trumpetsVanish = LerpColorInterval(trumpetNode, 0.29999999999999999, startColor = Vec4(1, 1, 0, 1), color = Vec4(1, 1, 0, 0))
crabHorn = globalBattleSoundCache.getSound('King_Crab.mp3')
drumroll = globalBattleSoundCache.getSound('SZ_MM_drumroll.mp3')
fanfare = globalBattleSoundCache.getSound('SZ_MM_fanfare.mp3')
crabHorn.setTime(1.5)
partyBall.setTransparency(1)
partyBall.setColorScale(1, 1, 1, 1)
ballAppear = Parallel(LerpColorScaleInterval(partyBallLeft, 0.29999999999999999, startColorScale = Vec4(1, 0, 0, 0), colorScale = Vec4(1, 0, 0, 1)), LerpColorScaleInterval(partyBallRight, 0.29999999999999999, startColorScale = Vec4(1, 1, 0, 0), colorScale = Vec4(1, 1, 0, 1)))
ballVanish = Parallel(LerpColorScaleInterval(partyBallLeft, 0.29999999999999999, startColorScale = Vec4(1, 0, 0, 1), colorScale = Vec4(1, 0, 0, 0)), LerpColorScaleInterval(partyBallRight, 0.29999999999999999, startColorScale = Vec4(1, 1, 0, 1), colorScale = Vec4(1, 1, 0, 0)))
play = Parallel(SoundInterval(crabHorn, startTime = 1.5, duration = 4.0, node = toon), Sequence(Wait(0.25), longshake([
trumpet1,
trumpet2], 3, 0.20000000000000001), Wait(0.5), longshake([
trumpet1,
trumpet2], 3, 0.20000000000000001), Wait(0.5), longshake([
trumpet1,
trumpet2], 9, 0.10000000000000001), longshake([
trumpet1,
trumpet2], 3, 0.20000000000000001)))
killParticles = Parallel(Func(blue_p0.setLitterSize, 0), Func(red_p0.setLitterSize, 0), Func(yellow_p0.setLitterSize, 0))
p = Parallel(ParticleInterval(confettiBlue, confettiNode, worldRelative = 0, duration = 3, cleanup = True), ParticleInterval(confettiRed, confettiNode, worldRelative = 0, duration = 3, cleanup = True), ParticleInterval(confettiYellow, confettiNode, worldRelative = 0, duration = 3, cleanup = True))
pOff = Parallel(Func(confettiBlue.remove), Func(confettiRed.remove), Func(confettiYellow.remove))
partInterval = Parallel(p, Sequence(Wait(1.7), killParticles, Wait(1.3), pOff, Func(p.finish)), Sequence(Wait(3), Parallel(ballVanish)))
seq1 = Parallel(Sequence(Wait(delay + 4.0999999999999996), SoundInterval(drumroll, node = toon), Wait(0.25), SoundInterval(fanfare, node = toon)), Sequence(Wait(delay), trumpetsAppear, Wait(3), ballAppear, Wait(0.5), ballShake1, Wait(0.10000000000000001), ballShake2, Wait(0.20000000000000001), Wait(0.10000000000000001), Parallel(openBall, partInterval), Func(fanfareNode.remove)))
seq = Parallel(seq1, Sequence(Wait(delay), Parallel(trumpetTurn, Sequence(Wait(0.5), play)), Wait(0.5), trumpetsVanish))
if panel != None:
return (seq, panel)
return (seq, None)
def __createWeddingCakeFlight(throw, groupHitDict, pie, pies):
toon = throw['toon']
battle = throw['battle']
level = throw['level']
sidestep = throw['sidestep']
hpbonus = throw['hpbonus']
numTargets = len(throw['target'])
pieName = pieNames[level]
splatName = 'splat-' + pieName
if pieName == 'wedding-cake':
splatName = 'splat-birthday-cake'
splat = globalPropPool.getProp(splatName)
splats = [splat]
for i in xrange(numTargets - 1):
splats.append(MovieUtil.copyProp(splat))
splatType = globalPropPool.getPropType(splatName)
cakePartStrs = ['cake1',
'cake2',
'cake3',
'caketop']
cakeParts = []
for part in cakePartStrs:
cakeParts.append(pie.find('**/%s' % part))
cakePartDivisions = {}
cakePartDivisions[1] = [[cakeParts[0],
cakeParts[1],
cakeParts[2],
cakeParts[3]]]
cakePartDivisions[2] = [[cakeParts[0], cakeParts[1]], [cakeParts[2], cakeParts[3]]]
cakePartDivisions[3] = [[cakeParts[0], cakeParts[1]], [cakeParts[2]], [cakeParts[3]]]
cakePartDivisions[4] = [[cakeParts[0]],
[cakeParts[1]],
[cakeParts[2]],
[cakeParts[3]]]
cakePartDivToUse = cakePartDivisions[len(throw['target'])]
groupPieTracks = Parallel()
for i in xrange(numTargets):
target = throw['target'][i]
suit = target['suit']
hitSuit = target['hp'] > 0
singlePieTrack = Sequence()
if hitSuit:
piePartReparent = Func(reparentCakePart, pie, cakePartDivToUse[i])
singlePieTrack.append(piePartReparent)
cakePartTrack = Parallel()
for cakePart in cakePartDivToUse[i]:
pieFly = LerpPosInterval(cakePart, tPieHitsSuit - tPieLeavesHand, pos=MovieUtil.avatarFacePoint(suit, other=battle), name=pieFlyTaskName, other=battle)
cakePartTrack.append(pieFly)
singlePieTrack.append(cakePartTrack)
pieRemoveCakeParts = Func(MovieUtil.removeProps, cakePartDivToUse[i])
pieHide = Func(MovieUtil.removeProps, pies)
splatShow = Func(__showProp, splats[i], suit, Point3(0, 0, suit.getHeight()))
splatBillboard = Func(__billboardProp, splats[i])
splatAnim = ActorInterval(splats[i], splatName)
splatHide = Func(MovieUtil.removeProp, splats[i])
singlePieTrack.append(pieRemoveCakeParts)
singlePieTrack.append(pieHide)
singlePieTrack.append(Func(battle.movie.clearRenderProp, pies[0]))
singlePieTrack.append(splatShow)
singlePieTrack.append(splatBillboard)
singlePieTrack.append(splatAnim)
singlePieTrack.append(splatHide)
else:
missDict = {}
if sidestep:
suitPoint = MovieUtil.avatarFacePoint(suit, other=battle)
else:
suitPoint = __suitMissPoint(suit, other=battle)
piePartReparent = Func(reparentCakePart, pie, cakePartDivToUse[i])
piePreMiss = Func(__piePreMissGroup, missDict, cakePartDivToUse[i], suitPoint, battle)
pieMiss = LerpFunctionInterval(__pieMissGroupLerpCallback, extraArgs=[missDict], duration=(tPieHitsSuit - tPieLeavesHand) * ratioMissToHit)
pieHide = Func(MovieUtil.removeProps, pies)
pieRemoveCakeParts = Func(MovieUtil.removeProps, cakePartDivToUse[i])
singlePieTrack.append(piePartReparent)
singlePieTrack.append(piePreMiss)
singlePieTrack.append(pieMiss)
singlePieTrack.append(pieRemoveCakeParts)
singlePieTrack.append(pieHide)
singlePieTrack.append(Func(battle.movie.clearRenderProp, pies[0]))
groupPieTracks.append(singlePieTrack)
return groupPieTracks
