def initIntervals(self):
self.baseSpinDuration = 1.0
self.propellerSpinLerp = LerpFunctionInterval(self.propeller.setH, fromData=0.0, toData=360.0, duration=self.baseSpinDuration, name='%s.propellerSpinLerp-%s' % (self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.TargetedWarningSingleBlinkTime
blinkTime = Globals.Gameplay.TargetedWarningBlinkTime
self.blinkLoop = Sequence(Wait(singleBlinkTime / 2.0), Func(self.setBackpackTexture, Globals.Gameplay.BackpackStates.Attacked), Wait(singleBlinkTime / 2.0), Func(self.setBackpackTexture, Globals.Gameplay.BackpackStates.Targeted), name='%s.blinkLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkWarningSeq = Sequence(Func(self.blinkLoop.loop), Wait(blinkTime), Func(self.blinkLoop.clearToInitial), name='%s.blinkWarningSeq-%s' % (self.__class__.__name__, self.toon.doId))
dur = Globals.Gameplay.BackpackRefuelDuration
self.refuelSeq = Sequence(Func(self.setPropellerSpinRate, Globals.Gameplay.RefuelPropSpeed), Wait(dur), Func(self.returnBackpackToLastStateFunc), name='%s.refuelSeq-%s' % (self.__class__.__name__, self.toon.doId))
scale = self.redTapeRing.getScale()
pulseTime = 1.0
self.pulseBubbleSeq = Parallel(Sequence(LerpFunctionInterval(self.redTapeRing.setScale, fromData=scale, toData=scale * 1.1, duration=pulseTime / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.redTapeRing.setScale, fromData=scale * 1.1, toData=scale, duration=pulseTime / 2.0, blendType='easeInOut')), LerpHprInterval(self.redTapeRing, pulseTime, Vec3(360, 0, 0), startHpr=Vec3(0, 0, 0)), name='%s.pulseBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
bouncePercent = 1.2
scaleTime = 0.5
scaleBounceTime = 0.25
self.popUpBubbleLerp = LerpScaleInterval(self.redTapeRing, scaleTime, scale * bouncePercent, startScale=0.0, blendType='easeInOut')
self.popUpBubbleSeq = Sequence(Func(self.updateLerpStartScale, self.popUpBubbleLerp, self.redTapeRing), Func(self.redTapeRing.show), self.popUpBubbleLerp, LerpScaleInterval(self.redTapeRing, scaleBounceTime, scale, startScale=scale * bouncePercent, blendType='easeInOut'), Func(self.pulseBubbleSeq.loop), name='%s.popUpBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
self.removeBubbleLerp = LerpScaleInterval(self.redTapeRing, scaleBounceTime, scale * bouncePercent, startScale=scale, blendType='easeInOut')
self.removeBubbleSeq = Sequence(Func(self.pulseBubbleSeq.clearToInitial), Func(self.updateLerpStartScale, self.removeBubbleLerp, self.redTapeRing), self.removeBubbleLerp, LerpScaleInterval(self.redTapeRing, scaleTime, 0.0, startScale=scale * bouncePercent, blendType='easeInOut'), Func(self.redTapeRing.hide), name='%s.removeBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
self.redTapeRing.setScale(0.0)
self.deathInterval = Sequence(Parallel(LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)), LerpFunctionInterval(self.toon.setScale, fromData=1.0, toData=0.1, duration=1.0)), Func(self.toon.stash), name='%s.deathInterval-%s' % (self.__class__.__name__, self.toon.doId))
self.spawnInterval = Sequence(Func(self.toon.stash), Func(self.resetToon), Wait(1.0), Func(self.toon.setAnimState, 'TeleportIn'), Func(self.toon.unstash), name='%s.spawnInterval-%s' % (self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.InvulSingleBlinkTime
blinkTime = Globals.Gameplay.InvulBlinkTime
invulBuffTime = Globals.Gameplay.InvulBuffTime
self.blinkBubbleLoop = Sequence(LerpFunctionInterval(self.redTapeRing.setAlphaScale, fromData=1.0, toData=0.0, duration=singleBlinkTime / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.redTapeRing.setAlphaScale, fromData=0.0, toData=1.0, duration=singleBlinkTime / 2.0, blendType='easeInOut'), name='%s.blinkBubbleLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkBubbleSeq = Sequence(Wait(invulBuffTime - blinkTime), Func(self.blinkBubbleLoop.loop), Wait(blinkTime), Func(self.blinkBubbleLoop.finish), name='%s.blinkBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
def loadAttack(self):
self.pen = loader.loadModel('phase_5/models/props/pen.bam')
self.pen.reparentTo(self.suit.find('**/joint_Rhold'))
self.sprayParticle = ParticleLoader.loadParticleEffect('phase_5/etc/penSpill.ptf')
self.spray = loader.loadModel('phase_3.5/models/props/spray.bam')
self.spray.setColor(VBase4(0, 0, 0, 1))
self.splat = Actor('phase_3.5/models/props/splat-mod.bam', {'chan': 'phase_3.5/models/props/splat-chan.bam'})
self.splat.setColor(VBase4(0, 0, 0, 1))
self.sprayScaleIval = LerpScaleInterval(self.spray, duration=0.3, scale=(1, 20, 1), startScale=(1, 1, 1))
sphere = CollisionSphere(0, 0, 0, 0.5)
sphere.setTangible(0)
if hasattr(self.suit, 'uniqueName'):
collName = self.suit.uniqueName('fountainPenCollNode')
else:
collName = 'fountainPenCollNode'
collNode = CollisionNode(collName)
collNode.addSolid(sphere)
collNode.setCollideMask(CIGlobals.WallBitmask)
self.wsnp = self.spray.attachNewNode(collNode)
self.wsnp.setY(1)
class CogdoFlyingPlayer(FSM):
notify = DirectNotifyGlobal.directNotify.newCategory('CogdoFlyingPlayer')
def __init__(self, toon):
FSM.__init__(self, 'CogdoFlyingPlayer')
self.toon = toon
self.toon.reparentTo(render)
self.legalEaglesTargeting = []
self.activeBuffs = []
self.initModels()
self.initIntervals()
self.netTimeSentToStartDeath = 0
self.backpackState = -1
self.lastBackpackState = -1
self.lastPropellerSpinRate = Globals.Gameplay.NormalPropSpeed
self.propellerSpinRate = Globals.Gameplay.NormalPropSpeed
self.setFuelState(Globals.Gameplay.FuelStates.FuelNoPropeller)
self.setOldFuelState(self.fuelState)
CogdoFlyingPlayer.setBlades(self, Globals.Gameplay.FuelStates.FuelNoPropeller)
self.setBackpackState(Globals.Gameplay.BackpackStates.Normal)
def initModels(self):
self.createPropeller()
self.createRedTapeRing()
def createPropeller(self):
self.propellerSmoke = DustCloud.DustCloud(self.toon, wantSound=False)
self.propellerSmoke.setBillboardPointEye()
self.propellerSmoke.setBin('fixed', 5002)
self.backpack = CogdoUtil.loadFlyingModel('propellerPack')
self.backpack.setScale(1.3)
self.backpack.setHpr(180.0, 0.0, 0.0)
self.backpackInstances = []
self.backpackTextureCard = CogdoUtil.loadFlyingModel('propellerPack_card')
parts = self.toon.getTorsoParts()
for part in parts:
backpackInstance = part.attachNewNode('backpackInstance')
animal = self.toon.style.getAnimal()
bodyScale = ToontownGlobals.toonBodyScales[animal]
backpackHeight = ToontownGlobals.torsoHeightDict[self.toon.style.torso] * bodyScale - 0.5
backpackInstance.setPos(0.0, -0.325, backpackHeight)
self.backpackInstances.append(backpackInstance)
self.backpack.instanceTo(backpackInstance)
self.propInstances = []
self.propeller = CogdoUtil.loadFlyingModel('toonPropeller')
for part in self.backpackInstances:
propInstance = part.attachNewNode('propInstance')
propInstance.setPos(0.0, -0.275, 0.0)
propInstance.setHpr(0.0, 20.0, 0.0)
propInstance.setScale(1.0, 1.0, 1.25)
self.propInstances.append(propInstance)
self.propeller.instanceTo(propInstance)
self.blades = []
self.activeBlades = []
index = 1
blade = self.propeller.find('**/propeller%d' % index)
while not blade.isEmpty():
self.blades.append(blade)
index += 1
blade = self.propeller.find('**/propeller%d' % index)
for blade in self.blades:
self.activeBlades.append(blade)
def createRedTapeRing(self):
self.redTapeRing = CogdoUtil.loadFlyingModel('redTapeRing')
self.redTapeRing.setTwoSided(True)
self.redTapeRing.reparentTo(self.toon)
self.redTapeRing.hide()
self.redTapeRing.setScale(1.25)
self.redTapeRing.setZ(self.toon.getHeight() / 2.0)
def initIntervals(self):
self.baseSpinDuration = 1.0
self.propellerSpinLerp = LerpFunctionInterval(self.propeller.setH, fromData=0.0, toData=360.0, duration=self.baseSpinDuration, name='%s.propellerSpinLerp-%s' % (self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.TargetedWarningSingleBlinkTime
blinkTime = Globals.Gameplay.TargetedWarningBlinkTime
self.blinkLoop = Sequence(Wait(singleBlinkTime / 2.0), Func(self.setBackpackTexture, Globals.Gameplay.BackpackStates.Attacked), Wait(singleBlinkTime / 2.0), Func(self.setBackpackTexture, Globals.Gameplay.BackpackStates.Targeted), name='%s.blinkLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkWarningSeq = Sequence(Func(self.blinkLoop.loop), Wait(blinkTime), Func(self.blinkLoop.clearToInitial), name='%s.blinkWarningSeq-%s' % (self.__class__.__name__, self.toon.doId))
dur = Globals.Gameplay.BackpackRefuelDuration
self.refuelSeq = Sequence(Func(self.setPropellerSpinRate, Globals.Gameplay.RefuelPropSpeed), Wait(dur), Func(self.returnBackpackToLastStateFunc), name='%s.refuelSeq-%s' % (self.__class__.__name__, self.toon.doId))
scale = self.redTapeRing.getScale()
pulseTime = 1.0
self.pulseBubbleSeq = Parallel(Sequence(LerpFunctionInterval(self.redTapeRing.setScale, fromData=scale, toData=scale * 1.1, duration=pulseTime / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.redTapeRing.setScale, fromData=scale * 1.1, toData=scale, duration=pulseTime / 2.0, blendType='easeInOut')), LerpHprInterval(self.redTapeRing, pulseTime, Vec3(360, 0, 0), startHpr=Vec3(0, 0, 0)), name='%s.pulseBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
bouncePercent = 1.2
scaleTime = 0.5
scaleBounceTime = 0.25
self.popUpBubbleLerp = LerpScaleInterval(self.redTapeRing, scaleTime, scale * bouncePercent, startScale=0.0, blendType='easeInOut')
self.popUpBubbleSeq = Sequence(Func(self.updateLerpStartScale, self.popUpBubbleLerp, self.redTapeRing), Func(self.redTapeRing.show), self.popUpBubbleLerp, LerpScaleInterval(self.redTapeRing, scaleBounceTime, scale, startScale=scale * bouncePercent, blendType='easeInOut'), Func(self.pulseBubbleSeq.loop), name='%s.popUpBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
self.removeBubbleLerp = LerpScaleInterval(self.redTapeRing, scaleBounceTime, scale * bouncePercent, startScale=scale, blendType='easeInOut')
self.removeBubbleSeq = Sequence(Func(self.pulseBubbleSeq.clearToInitial), Func(self.updateLerpStartScale, self.removeBubbleLerp, self.redTapeRing), self.removeBubbleLerp, LerpScaleInterval(self.redTapeRing, scaleTime, 0.0, startScale=scale * bouncePercent, blendType='easeInOut'), Func(self.redTapeRing.hide), name='%s.removeBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
self.redTapeRing.setScale(0.0)
self.deathInterval = Sequence(Parallel(LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)), LerpFunctionInterval(self.toon.setScale, fromData=1.0, toData=0.1, duration=1.0)), Func(self.toon.stash), name='%s.deathInterval-%s' % (self.__class__.__name__, self.toon.doId))
self.spawnInterval = Sequence(Func(self.toon.stash), Func(self.resetToon), Wait(1.0), Func(self.toon.setAnimState, 'TeleportIn'), Func(self.toon.unstash), name='%s.spawnInterval-%s' % (self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.InvulSingleBlinkTime
blinkTime = Globals.Gameplay.InvulBlinkTime
invulBuffTime = Globals.Gameplay.InvulBuffTime
self.blinkBubbleLoop = Sequence(LerpFunctionInterval(self.redTapeRing.setAlphaScale, fromData=1.0, toData=0.0, duration=singleBlinkTime / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.redTapeRing.setAlphaScale, fromData=0.0, toData=1.0, duration=singleBlinkTime / 2.0, blendType='easeInOut'), name='%s.blinkBubbleLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkBubbleSeq = Sequence(Wait(invulBuffTime - blinkTime), Func(self.blinkBubbleLoop.loop), Wait(blinkTime), Func(self.blinkBubbleLoop.finish), name='%s.blinkBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
def returnBackpackToLastStateFunc(self):
if self.backpackState == Globals.Gameplay.BackpackStates.Refuel:
self.returnBackpackToLastState()
def setPropellerSpinRateFunc(self):
if self.propellerSpinRate == Globals.Gameplay.RefuelPropSpeed:
self.setPropellerSpinRate(self.lastPropellerSpinRate)
def returnBackpackToLastState(self):
self.setBackpackState(self.lastBackpackState)
def setBackpackState(self, state):
if state == self.backpackState:
return
self.lastBackpackState = self.backpackState
self.backpackState = state
self.blinkWarningSeq.clearToInitial()
self.refuelSeq.clearToInitial()
self.blinkLoop.clearToInitial()
if self.lastBackpackState == Globals.Gameplay.BackpackStates.Refuel:
self.setPropellerSpinRateFunc()
if state in Globals.Gameplay.BackpackStates:
if state == Globals.Gameplay.BackpackStates.Normal:
pass
elif state == Globals.Gameplay.BackpackStates.Targeted:
pass
elif state == Globals.Gameplay.BackpackStates.Refuel:
self.refuelSeq.start()
elif state == Globals.Gameplay.BackpackStates.Attacked:
self.blinkWarningSeq.start()
self.setBackpackTexture(state)
def setBackpackTexture(self, state):
texName = Globals.Gameplay.BackpackState2TextureName[state]
tex = self.backpackTextureCard.findTexture(texName)
self.backpack.setTexture(tex, 1)
def updateLerpStartScale(self, lerp, nodepath):
lerp.setStartScale(nodepath.getScale())
def handleEnterGatherable(self, gatherable, elapsedTime):
if gatherable.type == Globals.Level.GatherableTypes.InvulPowerup:
self.blinkBubbleSeq.clearToInitial()
self.blinkBubbleSeq.start(elapsedTime)
self.removeBubbleSeq.clearToInitial()
self.popUpBubbleSeq.start()
if gatherable.type not in self.activeBuffs:
self.activeBuffs.append(gatherable.type)
elif gatherable.type == Globals.Level.GatherableTypes.Propeller:
self.setBackpackState(Globals.Gameplay.BackpackStates.Refuel)
def handleDebuffPowerup(self, pickupType, elapsedTime):
if pickupType == Globals.Level.GatherableTypes.InvulPowerup:
self.blinkBubbleSeq.finish()
self.popUpBubbleSeq.clearToInitial()
self.removeBubbleSeq.start()
if pickupType in self.activeBuffs:
self.activeBuffs.remove(pickupType)
def isBuffActive(self, pickupType):
if pickupType in self.activeBuffs:
return True
return False
def isInvulnerable(self):
if Globals.Level.GatherableTypes.InvulPowerup in self.activeBuffs:
return True
return False
def setFuelState(self, fuelState):
self.fuelState = fuelState
def setOldFuelState(self, fuelState):
self.oldFuelState = fuelState
def hasFuelStateChanged(self):
if self.fuelState != self.oldFuelState:
return True
else:
return False
def updatePropellerSmoke(self):
if not self.hasFuelStateChanged():
return
if self.fuelState in [Globals.Gameplay.FuelStates.FuelNoPropeller, Globals.Gameplay.FuelStates.FuelNormal]:
self.propellerSmoke.stop()
elif self.fuelState in [Globals.Gameplay.FuelStates.FuelVeryLow, Globals.Gameplay.FuelStates.FuelEmpty]:
self.propellerSmoke.stop()
self.propellerSmoke.setScale(0.25)
self.propellerSmoke.setZ(self.toon.getHeight() + 2.5)
self.propellerSmoke.loop(rate=48)
elif self.fuelState in [Globals.Gameplay.FuelStates.FuelLow]:
self.propellerSmoke.stop()
self.propellerSmoke.setScale(0.0825)
self.propellerSmoke.setZ(self.toon.getHeight() + 2.0)
self.propellerSmoke.loop(rate=24)
def resetBlades(self):
self.setBlades(len(self.blades))
def setAsLegalEagleTarget(self, legalEagle):
if legalEagle not in self.legalEaglesTargeting:
self.legalEaglesTargeting.append(legalEagle)
def removeAsLegalEagleTarget(self, legalEagle):
if legalEagle in self.legalEaglesTargeting:
self.legalEaglesTargeting.remove(legalEagle)
def isLegalEagleTarget(self):
if len(self.legalEaglesTargeting) > 0:
return True
else:
return False
def setBlades(self, fuelState):
if fuelState not in Globals.Gameplay.FuelStates:
return
numBlades = fuelState - 1
if len(self.activeBlades) != numBlades:
for i in xrange(len(self.activeBlades)):
blade = self.activeBlades.pop()
blade.stash()
if numBlades > len(self.blades):
numBlades = len(self.blades)
if numBlades > 0:
for i in xrange(numBlades):
blade = self.blades[i]
self.activeBlades.append(blade)
blade.unstash()
if fuelState == Globals.Gameplay.FuelStates.FuelNoPropeller:
for prop in self.propInstances:
prop.hide()
else:
for prop in self.propInstances:
prop.show()
self.setFuelState(fuelState)
self.updatePropellerSmoke()
self.setOldFuelState(self.fuelState)
def bladeLost(self):
if len(self.activeBlades) > 0:
blade = self.activeBlades.pop()
blade.stash()
self.setFuelState(len(self.activeBlades) + 1)
self.updatePropellerSmoke()
self.setOldFuelState(self.fuelState)
def setPropellerSpinRate(self, newRate):
self.lastPropellerSpinRate = self.propellerSpinRate
self.propellerSpinRate = newRate
self.notify.debug('(%s) New propeller speed:%s, old propeller speed:%s' % (self.toon.doId, self.propellerSpinRate, self.lastPropellerSpinRate))
self.propellerSpinLerp.setPlayRate(newRate)
def died(self, elapsedTime):
self.deathInterval.start(elapsedTime)
self.propellerSmoke.stop()
def spawn(self, elapsedTime):
self.spawnInterval.start(elapsedTime)
def resetToon(self):
self.toon.setScale(1.0)
def enable(self):
self.toon.setAnimState('Happy', 1.0)
self.toon.setForceJumpIdle(True)
self.toon.setSpeed(0, 0)
self.setPropellerSpinRate(Globals.Gameplay.NormalPropSpeed)
self.propellerSpinLerp.loop()
def disable(self):
pass
def unload(self):
self.ignoreAll()
if self.toon:
self.toon.showName()
self.backpackTextureCard.removeNode()
del self.backpackTextureCard
self.refuelSeq.clearToInitial()
del self.refuelSeq
self.pulseBubbleSeq.clearToInitial()
del self.pulseBubbleSeq
self.blinkBubbleLoop.clearToInitial()
del self.blinkBubbleLoop
self.blinkBubbleSeq.clearToInitial()
del self.blinkBubbleSeq
self.popUpBubbleLerp.clearToInitial()
del self.popUpBubbleLerp
self.popUpBubbleSeq.clearToInitial()
del self.popUpBubbleSeq
self.removeBubbleLerp.clearToInitial()
del self.removeBubbleLerp
self.removeBubbleSeq.clearToInitial()
del self.removeBubbleSeq
self.propellerSmoke.destroy()
del self.propellerSmoke
self.blinkWarningSeq.clearToInitial()
del self.blinkWarningSeq
self.blinkLoop.clearToInitial()
del self.blinkLoop
self.redTapeRing.removeNode()
del self.redTapeRing
self.propellerSpinLerp.clearToInitial()
del self.propellerSpinLerp
for prop in self.propInstances:
prop.removeNode()
del self.propInstances[:]
self.propeller.removeNode()
del self.propeller
for backpack in self.backpackInstances:
backpack.removeNode()
del self.backpackInstances[:]
self.backpack.removeNode()
del self.backpack
del self.activeBuffs[:]
del self.legalEaglesTargeting[:]
del self.toon
self.toon = None
if self.deathInterval:
self.deathInterval.clearToInitial()
self.deathInterval = None
if self.spawnInterval:
self.spawnInterval.clearToInitial()
self.spawnInterval = None
return
def start(self):
swapAvatarShadowPlacer(self.toon, self.toon.uniqueName('toonShadowPlacer'))
self.toon.startSmooth()
def exit(self):
self.toon.setForceJumpIdle(False)
self.propellerSmoke.reparentTo(hidden)
self.propellerSmoke.stop()
if self.toon:
CogdoFlyingPlayer.resetToon(self)
self.toon.setActiveShadow(0)
self.toon.deleteDropShadow()
self.toon.initializeDropShadow()
self.toon.setActiveShadow(1)
else:
self.notify.warning("There's no toon in offstage, this is bad!")
def showResults(self):
if not self.gameIsEnding:
self.gameIsEnding = True
for barrel in self.barrels:
barrel.wrtReparentTo(render)
for key in self.cogInfo:
thief = self.cogInfo[key]['suit']
thief.suit.setPos(100, 0, 0)
thief.suit.hide()
self.__killRewardCountdown()
self.stopGameWalk()
numBarrelsSaved = len(self.barrels) - len(self.stolenBarrels)
resultStr = ''
if numBarrelsSaved == len(self.barrels):
resultStr = TTLocalizer.CogThiefPerfect
elif numBarrelsSaved > 1:
resultStr = TTLocalizer.CogThiefBarrelsSaved % {
'num': numBarrelsSaved
}
elif numBarrelsSaved == 1:
resultStr = TTLocalizer.CogThiefBarrelSaved % {
'num': numBarrelsSaved
}
else:
resultStr = TTLocalizer.CogThiefNoBarrelsSaved
perfectTextSubnode = hidden.attachNewNode(
self.__genText(resultStr))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text=perfectText):
text.removeNode()
def safeGameOver(self=self):
if not self.frameworkFSM.isInternalStateInFlux():
self.gameOver()
textTrack = Sequence(
Func(perfectText.reparentTo, aspect2d),
Parallel(
LerpScaleInterval(perfectText,
duration=0.5,
scale=0.3,
startScale=0.0),
LerpFunctionInterval(fadeFunc,
fromData=0.0,
toData=1.0,
duration=0.5)), Wait(2.0),
Parallel(
LerpScaleInterval(perfectText, duration=0.5, scale=1.0),
LerpFunctionInterval(fadeFunc,
fromData=1.0,
toData=0.0,
duration=0.5,
blendType='easeIn')),
Func(destroyText), WaitInterval(0.5), Func(safeGameOver))
if numBarrelsSaved == len(self.barrels):
soundTrack = SoundInterval(self.sndPerfect)
else:
soundTrack = Sequence()
self.resultIval = Parallel(textTrack, soundTrack)
self.resultIval.start()
def onActivate(self, entity, suit):
ActivateTrapGag.onActivate(self, entity, suit)
x, y, z = entity.getPos(render)
sinkPos = Point3(x, y, z - 9.1)
dropPos = Point3(x, y, z + 15)
landPos = Point3(x, y, z)
suit.d_disableMovement()
suit.setPos(x, y, z)
entTrack = Sequence(Wait(0.4), Func(entity.setColor, Vec4(0, 0, 0, 1)), Wait(0.4), LerpScaleInterval(entity, 0.8, GagGlobals.PNT3NEAR0))
suitTrack = Sequence(
self.getSplicedLerpAnimsTrack(suit, 'flail', 0.7, 0.25),
Wait(0.2),
LerpPosInterval(suit, 0.4, sinkPos),
Func(suit.setPos, dropPos),
Func(suit.hide),
ActorInterval(suit, 'neutral', duration=0.5),
Wait(0.75),
Func(suit.show),
Parallel(LerpPosInterval(suit, 0.3, landPos), Func(suit.play, 'slip-forward')),
SoundInterval(self.activateSfx, node = suit),
Func(self.damageSuit, suit),
Func(suit.d_enableMovement)
)
soundTrack = Sequence(SoundInterval(self.hitSfx, node = suit), Wait(0.8))
Parallel(entTrack, suitTrack, soundTrack).start()
class CogdoFlyingPlayer(FSM):
notify = DirectNotifyGlobal.directNotify.newCategory('CogdoFlyingPlayer')
def __init__(self, toon):
FSM.__init__(self, 'CogdoFlyingPlayer')
self.toon = toon
self.toon.reparentTo(render)
self.legalEaglesTargeting = []
self.activeBuffs = []
self.initModels()
self.initIntervals()
self.netTimeSentToStartDeath = 0
self.backpackState = -1
self.lastBackpackState = -1
self.lastPropellerSpinRate = Globals.Gameplay.NormalPropSpeed
self.propellerSpinRate = Globals.Gameplay.NormalPropSpeed
self.setFuelState(Globals.Gameplay.FuelStates.FuelNoPropeller)
self.setOldFuelState(self.fuelState)
CogdoFlyingPlayer.setBlades(self, Globals.Gameplay.FuelStates.FuelNoPropeller)
self.setBackpackState(Globals.Gameplay.BackpackStates.Normal)
def initModels(self):
self.createPropeller()
self.createRedTapeRing()
def createPropeller(self):
self.propellerSmoke = DustCloud.DustCloud(self.toon, wantSound=False)
self.propellerSmoke.setBillboardPointEye()
self.propellerSmoke.setBin('fixed', 5002)
self.backpack = CogdoUtil.loadFlyingModel('propellerPack')
self.backpack.setScale(1.3)
self.backpack.setHpr(180.0, 0.0, 0.0)
self.backpackInstances = []
self.backpackTextureCard = CogdoUtil.loadFlyingModel('propellerPack_card')
parts = self.toon.getTorsoParts()
for part in parts:
backpackInstance = part.attachNewNode('backpackInstance')
animal = self.toon.style.getAnimal()
bodyScale = ToontownGlobals.toonBodyScales[animal]
backpackHeight = ToontownGlobals.torsoHeightDict[self.toon.style.torso] * bodyScale - 0.5
backpackInstance.setPos(0.0, -0.325, backpackHeight)
self.backpackInstances.append(backpackInstance)
self.backpack.instanceTo(backpackInstance)
self.propInstances = []
self.propeller = CogdoUtil.loadFlyingModel('toonPropeller')
for part in self.backpackInstances:
propInstance = part.attachNewNode('propInstance')
propInstance.setPos(0.0, -0.275, 0.0)
propInstance.setHpr(0.0, 20.0, 0.0)
propInstance.setScale(1.0, 1.0, 1.25)
self.propInstances.append(propInstance)
self.propeller.instanceTo(propInstance)
self.blades = []
self.activeBlades = []
index = 1
blade = self.propeller.find('**/propeller%d' % index)
while not blade.isEmpty():
self.blades.append(blade)
index += 1
blade = self.propeller.find('**/propeller%d' % index)
for blade in self.blades:
self.activeBlades.append(blade)
def createRedTapeRing(self):
self.redTapeRing = CogdoUtil.loadFlyingModel('redTapeRing')
self.redTapeRing.setTwoSided(True)
self.redTapeRing.reparentTo(self.toon)
self.redTapeRing.hide()
self.redTapeRing.setScale(1.25)
self.redTapeRing.setZ(self.toon.getHeight() / 2.0)
def initIntervals(self):
self.baseSpinDuration = 1.0
self.propellerSpinLerp = LerpFunctionInterval(self.propeller.setH, fromData=0.0, toData=360.0, duration=self.baseSpinDuration, name='%s.propellerSpinLerp-%s' % (self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.TargetedWarningSingleBlinkTime
blinkTime = Globals.Gameplay.TargetedWarningBlinkTime
self.blinkLoop = Sequence(Wait(singleBlinkTime / 2.0), Func(self.setBackpackTexture, Globals.Gameplay.BackpackStates.Attacked), Wait(singleBlinkTime / 2.0), Func(self.setBackpackTexture, Globals.Gameplay.BackpackStates.Targeted), name='%s.blinkLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkWarningSeq = Sequence(Func(self.blinkLoop.loop), Wait(blinkTime), Func(self.blinkLoop.clearToInitial), name='%s.blinkWarningSeq-%s' % (self.__class__.__name__, self.toon.doId))
dur = Globals.Gameplay.BackpackRefuelDuration
self.refuelSeq = Sequence(Func(self.setPropellerSpinRate, Globals.Gameplay.RefuelPropSpeed), Wait(dur), Func(self.returnBackpackToLastStateFunc), name='%s.refuelSeq-%s' % (self.__class__.__name__, self.toon.doId))
scale = self.redTapeRing.getScale()
pulseTime = 1.0
self.pulseBubbleSeq = Parallel(Sequence(LerpFunctionInterval(self.redTapeRing.setScale, fromData=scale, toData=scale * 1.1, duration=pulseTime / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.redTapeRing.setScale, fromData=scale * 1.1, toData=scale, duration=pulseTime / 2.0, blendType='easeInOut')), LerpHprInterval(self.redTapeRing, pulseTime, Vec3(360, 0, 0), startHpr=Vec3(0, 0, 0)), name='%s.pulseBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
bouncePercent = 1.2
scaleTime = 0.5
scaleBounceTime = 0.25
self.popUpBubbleLerp = LerpScaleInterval(self.redTapeRing, scaleTime, scale * bouncePercent, startScale=0.0, blendType='easeInOut')
self.popUpBubbleSeq = Sequence(Func(self.updateLerpStartScale, self.popUpBubbleLerp, self.redTapeRing), Func(self.redTapeRing.show), self.popUpBubbleLerp, LerpScaleInterval(self.redTapeRing, scaleBounceTime, scale, startScale=scale * bouncePercent, blendType='easeInOut'), Func(self.pulseBubbleSeq.loop), name='%s.popUpBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
self.removeBubbleLerp = LerpScaleInterval(self.redTapeRing, scaleBounceTime, scale * bouncePercent, startScale=scale, blendType='easeInOut')
self.removeBubbleSeq = Sequence(Func(self.pulseBubbleSeq.clearToInitial), Func(self.updateLerpStartScale, self.removeBubbleLerp, self.redTapeRing), self.removeBubbleLerp, LerpScaleInterval(self.redTapeRing, scaleTime, 0.0, startScale=scale * bouncePercent, blendType='easeInOut'), Func(self.redTapeRing.hide), name='%s.removeBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
self.redTapeRing.setScale(0.0)
self.deathInterval = Sequence(Parallel(LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)), LerpFunctionInterval(self.toon.setScale, fromData=1.0, toData=0.1, duration=1.0)), Func(self.toon.stash), name='%s.deathInterval-%s' % (self.__class__.__name__, self.toon.doId))
self.spawnInterval = Sequence(Func(self.toon.stash), Func(self.resetToon), Wait(1.0), Func(self.toon.setAnimState, 'TeleportIn'), Func(self.toon.unstash), name='%s.spawnInterval-%s' % (self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.InvulSingleBlinkTime
blinkTime = Globals.Gameplay.InvulBlinkTime
invulBuffTime = Globals.Gameplay.InvulBuffTime
self.blinkBubbleLoop = Sequence(LerpFunctionInterval(self.redTapeRing.setAlphaScale, fromData=1.0, toData=0.0, duration=singleBlinkTime / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.redTapeRing.setAlphaScale, fromData=0.0, toData=1.0, duration=singleBlinkTime / 2.0, blendType='easeInOut'), name='%s.blinkBubbleLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkBubbleSeq = Sequence(Wait(invulBuffTime - blinkTime), Func(self.blinkBubbleLoop.loop), Wait(blinkTime), Func(self.blinkBubbleLoop.finish), name='%s.blinkBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
def returnBackpackToLastStateFunc(self):
if self.backpackState == Globals.Gameplay.BackpackStates.Refuel:
self.returnBackpackToLastState()
def setPropellerSpinRateFunc(self):
if self.propellerSpinRate == Globals.Gameplay.RefuelPropSpeed:
self.setPropellerSpinRate(self.lastPropellerSpinRate)
def returnBackpackToLastState(self):
self.setBackpackState(self.lastBackpackState)
def setBackpackState(self, state):
if state == self.backpackState:
return
self.lastBackpackState = self.backpackState
self.backpackState = state
self.blinkWarningSeq.clearToInitial()
self.refuelSeq.clearToInitial()
self.blinkLoop.clearToInitial()
if self.lastBackpackState == Globals.Gameplay.BackpackStates.Refuel:
self.setPropellerSpinRateFunc()
if state in Globals.Gameplay.BackpackStates:
if state == Globals.Gameplay.BackpackStates.Normal:
pass
elif state == Globals.Gameplay.BackpackStates.Targeted:
pass
elif state == Globals.Gameplay.BackpackStates.Refuel:
self.refuelSeq.start()
elif state == Globals.Gameplay.BackpackStates.Attacked:
self.blinkWarningSeq.start()
self.setBackpackTexture(state)
def setBackpackTexture(self, state):
texName = Globals.Gameplay.BackpackState2TextureName[state]
tex = self.backpackTextureCard.findTexture(texName)
self.backpack.setTexture(tex, 1)
def updateLerpStartScale(self, lerp, nodepath):
lerp.setStartScale(nodepath.getScale())
def handleEnterGatherable(self, gatherable, elapsedTime):
if gatherable.type == Globals.Level.GatherableTypes.InvulPowerup:
self.blinkBubbleSeq.clearToInitial()
self.blinkBubbleSeq.start(elapsedTime)
self.removeBubbleSeq.clearToInitial()
self.popUpBubbleSeq.start()
if gatherable.type not in self.activeBuffs:
self.activeBuffs.append(gatherable.type)
elif gatherable.type == Globals.Level.GatherableTypes.Propeller:
self.setBackpackState(Globals.Gameplay.BackpackStates.Refuel)
def handleDebuffPowerup(self, pickupType, elapsedTime):
if pickupType == Globals.Level.GatherableTypes.InvulPowerup:
self.blinkBubbleSeq.finish()
self.popUpBubbleSeq.clearToInitial()
self.removeBubbleSeq.start()
if pickupType in self.activeBuffs:
self.activeBuffs.remove(pickupType)
def isBuffActive(self, pickupType):
if pickupType in self.activeBuffs:
return True
return False
def isInvulnerable(self):
if Globals.Level.GatherableTypes.InvulPowerup in self.activeBuffs:
return True
return False
def setFuelState(self, fuelState):
self.fuelState = fuelState
def setOldFuelState(self, fuelState):
self.oldFuelState = fuelState
def hasFuelStateChanged(self):
if self.fuelState != self.oldFuelState:
return True
else:
return False
def updatePropellerSmoke(self):
if not self.hasFuelStateChanged():
return
if self.fuelState in [Globals.Gameplay.FuelStates.FuelNoPropeller, Globals.Gameplay.FuelStates.FuelNormal]:
self.propellerSmoke.stop()
elif self.fuelState in [Globals.Gameplay.FuelStates.FuelVeryLow, Globals.Gameplay.FuelStates.FuelEmpty]:
self.propellerSmoke.stop()
self.propellerSmoke.setScale(0.25)
self.propellerSmoke.setZ(self.toon.getHeight() + 2.5)
self.propellerSmoke.loop(rate=48)
elif self.fuelState in [Globals.Gameplay.FuelStates.FuelLow]:
self.propellerSmoke.stop()
self.propellerSmoke.setScale(0.0825)
self.propellerSmoke.setZ(self.toon.getHeight() + 2.0)
self.propellerSmoke.loop(rate=24)
def resetBlades(self):
self.setBlades(len(self.blades))
def setAsLegalEagleTarget(self, legalEagle):
if legalEagle not in self.legalEaglesTargeting:
self.legalEaglesTargeting.append(legalEagle)
def removeAsLegalEagleTarget(self, legalEagle):
if legalEagle in self.legalEaglesTargeting:
self.legalEaglesTargeting.remove(legalEagle)
def isLegalEagleTarget(self):
if len(self.legalEaglesTargeting) > 0:
return True
else:
return False
def setBlades(self, fuelState):
if fuelState not in Globals.Gameplay.FuelStates:
return
numBlades = fuelState - 1
if len(self.activeBlades) != numBlades:
for i in range(len(self.activeBlades)):
blade = self.activeBlades.pop()
blade.stash()
if numBlades > len(self.blades):
numBlades = len(self.blades)
if numBlades > 0:
for i in range(numBlades):
blade = self.blades[i]
self.activeBlades.append(blade)
blade.unstash()
if fuelState == Globals.Gameplay.FuelStates.FuelNoPropeller:
for prop in self.propInstances:
prop.hide()
else:
for prop in self.propInstances:
prop.show()
self.setFuelState(fuelState)
self.updatePropellerSmoke()
self.setOldFuelState(self.fuelState)
def bladeLost(self):
if len(self.activeBlades) > 0:
blade = self.activeBlades.pop()
blade.stash()
self.setFuelState(len(self.activeBlades) + 1)
self.updatePropellerSmoke()
self.setOldFuelState(self.fuelState)
def setPropellerSpinRate(self, newRate):
self.lastPropellerSpinRate = self.propellerSpinRate
self.propellerSpinRate = newRate
self.notify.debug('(%s) New propeller speed:%s, old propeller speed:%s' % (self.toon.doId, self.propellerSpinRate, self.lastPropellerSpinRate))
self.propellerSpinLerp.setPlayRate(newRate)
def died(self, elapsedTime):
self.deathInterval.start(elapsedTime)
self.propellerSmoke.stop()
def spawn(self, elapsedTime):
self.spawnInterval.start(elapsedTime)
def resetToon(self):
self.toon.setScale(1.0)
def enable(self):
self.toon.setAnimState('Happy', 1.0)
self.toon.setForceJumpIdle(True)
self.toon.setSpeed(0, 0)
self.setPropellerSpinRate(Globals.Gameplay.NormalPropSpeed)
self.propellerSpinLerp.loop()
def disable(self):
pass
def unload(self):
self.ignoreAll()
if self.toon:
self.toon.showName()
self.backpackTextureCard.removeNode()
del self.backpackTextureCard
self.refuelSeq.clearToInitial()
del self.refuelSeq
self.pulseBubbleSeq.clearToInitial()
del self.pulseBubbleSeq
self.blinkBubbleLoop.clearToInitial()
del self.blinkBubbleLoop
self.blinkBubbleSeq.clearToInitial()
del self.blinkBubbleSeq
self.popUpBubbleLerp.clearToInitial()
del self.popUpBubbleLerp
self.popUpBubbleSeq.clearToInitial()
del self.popUpBubbleSeq
self.removeBubbleLerp.clearToInitial()
del self.removeBubbleLerp
self.removeBubbleSeq.clearToInitial()
del self.removeBubbleSeq
self.propellerSmoke.destroy()
del self.propellerSmoke
self.blinkWarningSeq.clearToInitial()
del self.blinkWarningSeq
self.blinkLoop.clearToInitial()
del self.blinkLoop
self.redTapeRing.removeNode()
del self.redTapeRing
self.propellerSpinLerp.clearToInitial()
del self.propellerSpinLerp
for prop in self.propInstances:
prop.removeNode()
del self.propInstances[:]
self.propeller.removeNode()
del self.propeller
for backpack in self.backpackInstances:
backpack.removeNode()
del self.backpackInstances[:]
self.backpack.removeNode()
del self.backpack
del self.activeBuffs[:]
del self.legalEaglesTargeting[:]
del self.toon
self.toon = None
if self.deathInterval:
self.deathInterval.clearToInitial()
self.deathInterval = None
if self.spawnInterval:
self.spawnInterval.clearToInitial()
self.spawnInterval = None
return
def start(self):
swapAvatarShadowPlacer(self.toon, self.toon.uniqueName('toonShadowPlacer'))
self.toon.startSmooth()
def exit(self):
self.toon.setForceJumpIdle(False)
self.propellerSmoke.reparentTo(hidden)
self.propellerSmoke.stop()
if self.toon:
CogdoFlyingPlayer.resetToon(self)
self.toon.setActiveShadow(0)
self.toon.deleteDropShadow()
self.toon.initializeDropShadow()
self.toon.setActiveShadow(1)
else:
self.notify.warning("There's no toon in offstage, this is bad!")
def setHillType(self, type):
if self.isUp and (self.hillType == MoleFieldBase.HILL_MOLE
and type == MoleFieldBase.HILL_BOMB
or self.hillType == MoleFieldBase.HILL_BOMB
and type == MoleFieldBase.HILL_MOLE):
return
self.hillType = type
self.moleHead.remove()
if type == MoleFieldBase.HILL_MOLE:
self.moleHead = loader.loadModel(
'phase_12/models/bossbotHQ/mole_norm')
self.moleColNodePath.setScale(3.0)
self.moleHead.setH(0)
self.mole.setBillboardAxis(localAvatar, 0)
if type == MoleFieldBase.HILL_BOMB or type == MoleFieldBase.HILL_COGWHACKED:
self.moleHead = loader.loadModel(
'phase_12/models/bossbotHQ/mole_cog')
self.moleColNodePath.setScale(1.0)
self.mole.setBillboardAxis(localAvatar, 0)
if type == MoleFieldBase.HILL_COGWHACKED:
self.doMoleDown()
BattleParticles.loadParticles()
singleGear = BattleParticles.createParticleEffect(
'GearExplosion', numParticles=1)
smallGearExplosion = BattleParticles.createParticleEffect(
'GearExplosion', numParticles=10)
bigGearExplosion = BattleParticles.createParticleEffect(
'BigGearExplosion', numParticles=30)
gears2MTrack = Track((0.0,
ParticleInterval(singleGear,
self.hill,
worldRelative=1,
duration=5.7,
cleanup=True)),
(0.0,
ParticleInterval(smallGearExplosion,
self.hill,
worldRelative=0,
duration=1.2,
cleanup=True)),
(0.3,
ParticleInterval(bigGearExplosion,
self.hill,
worldRelative=0,
duration=1.0,
cleanup=True)),
name='gears2MTrack')
gears2MTrack.start()
self.popIval = Sequence(
Parallel(
Sequence(
LerpPosInterval(self.moleHead, 0.05,
Point3(0.28, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, -0.23, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.28)),
LerpPosInterval(self.moleHead, 0.05,
Point3(-0.35, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.28, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.31, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, -0.32, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.48)),
LerpPosInterval(self.moleHead, 0.05,
Point3(-0.28, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.29, 0.0)))),
LerpPosInterval(self.mole, 0.5, Point3(0, 0, -2.5)),
Func(self.setHillType, MoleFieldBase.HILL_BOMB))
self.popIval.start()
else:
self.moleHead.setH(0)
if type == MoleFieldBase.HILL_WHACKED:
self.moleHead = loader.loadModel(
'phase_12/models/bossbotHQ/mole_hit')
self.mole.setBillboardAxis(0)
self.moleColNodePath.setScale(0.0)
if self.popIval:
self.popIval.finish()
if self.downIval:
self.downIval.finish()
self.mole.setPos(0.0, 0.0, 0.0)
self.popIval = Sequence(
Parallel(
Sequence(
LerpPosInterval(self.moleHead, 0.05,
Point3(0.18, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, -0.13, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.18)),
LerpPosInterval(self.moleHead, 0.05,
Point3(-0.15, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.18, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.11, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, -0.12, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.18)),
LerpPosInterval(self.moleHead, 0.05,
Point3(-0.18, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.13, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.18, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, -0.15, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.18)),
LerpPosInterval(self.moleHead, 0.05,
Point3(-0.16, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.18, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.11, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, -0.18, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.17)),
LerpPosInterval(self.moleHead, 0.05,
Point3(-0.18, 0.0, 0.0)),
LerpPosInterval(self.moleHead, 0.05,
Point3(0.0, 0.0, 0.0))),
Sequence(LerpScaleInterval(self.moleHead, 0.5, 3.5),
LerpScaleInterval(self.moleHead, 0.5, 1.0))),
LerpPosInterval(self.mole, 0.5, Point3(0, 0, -2.5)),
Func(self.setHillType, MoleFieldBase.HILL_MOLE))
self.popIval.start()
self.moleHead.reparentTo(self.mole)
def enterFinalResults(self):
lerpTrack = Parallel()
lerpDur = 0.5
tY = 0.6
bY = -.05
lX = -.5
cX = 0
rX = 0.5
scorePanelLocs = (((cX, bY),),
((lX, bY), (rX, bY)),
((cX, tY), (lX, bY), (rX, bY)),
((lX, tY),
(rX, tY),
(lX, bY),
(rX, bY)))
scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
panel.wrtReparentTo(aspect2d)
lerpTrack.append(Parallel(LerpPosInterval(panel, lerpDur, Point3(pos[0], 0, pos[1]), blendType='easeInOut'), LerpScaleInterval(panel, lerpDur, Vec3(panel.getScale()) * 2.0, blendType='easeInOut')))
self.showScoreTrack = Parallel(lerpTrack, Sequence(Wait(IceGameGlobals.ShowScoresDuration), Func(self.gameOver)))
self.showScoreTrack.start()
def enterScoring(self):
sortedByDistance = []
for avId in self.avIdList:
np = self.getTireNp(avId)
pos = np.getPos()
pos.setZ(0)
sortedByDistance.append((avId, pos.length()))
def compareDistance(x, y):
if x[1] - y[1] > 0:
return 1
elif x[1] - y[1] < 0:
return -1
else:
return 0
sortedByDistance.sort(cmp=compareDistance)
self.scoreMovie = Sequence()
curScale = 0.01
curTime = 0
self.scoreCircle.setScale(0.01)
self.scoreCircle.show()
self.notify.debug('newScores = %s' % self.newScores)
circleStartTime = 0
for index in xrange(len(sortedByDistance)):
distance = sortedByDistance[index][1]
avId = sortedByDistance[index][0]
scorePanelIndex = self.avIdList.index(avId)
time = (distance - curScale) / IceGameGlobals.ExpandFeetPerSec
if time < 0:
time = 0.01
scaleXY = distance + IceGameGlobals.TireRadius
self.notify.debug('circleStartTime = %s' % circleStartTime)
self.scoreMovie.append(
Parallel(
LerpScaleInterval(self.scoreCircle, time,
Point3(scaleXY, scaleXY, 1.0)),
SoundInterval(self.scoreCircleSound,
duration=time,
startTime=circleStartTime)))
circleStartTime += time
startScore = self.scorePanels[scorePanelIndex].getScore()
destScore = self.newScores[scorePanelIndex]
self.notify.debug('for avId %d, startScore=%d, newScores=%d' %
(avId, startScore, destScore))
def increaseScores(t,
scorePanelIndex=scorePanelIndex,
startScore=startScore,
destScore=destScore):
oldScore = self.scorePanels[scorePanelIndex].getScore()
diff = destScore - startScore
newScore = int(startScore + diff * t)
if newScore > oldScore:
base.playSfx(self.countSound)
self.scorePanels[scorePanelIndex].setScore(newScore)
self.scores[scorePanelIndex] = newScore
duration = (destScore -
startScore) * IceGameGlobals.ScoreCountUpRate
tireNp = self.tireDict[avId]['tireNodePath']
self.scoreMovie.append(
Parallel(
LerpFunctionInterval(increaseScores, duration),
Sequence(
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)))))
curScale += distance
self.scoreMovie.append(
Func(self.sendUpdate, 'reportScoringMovieDone', []))
self.scoreMovie.start()
def animToToon(self, timeStamp):
self.stopTransition()
if self.mode != 'suit':
self.setToSuit()
self.loadAnimToToonSfx()
suitSoundPlayed = 0
toonSoundPlayed = 0
bldgNodes = self.getNodePaths()
tracks = Parallel()
for i in bldgNodes:
name = i.getName()
if name[0] == 's':
hideTrack = Sequence(name=self.taskName('ToToonSuitFlatsTrack'))
landmark = name.find('_landmark_') != -1
if not suitSoundPlayed:
hideTrack.append(Func(base.playSfx, self.cogWeakenSound, 0, 1, None, 0.0))
hideTrack.append(self.createBounceTrack(i, 3, 1.2, TO_TOON_BLDG_TIME * 0.05, slowInitBounce=0.0))
hideTrack.append(self.createBounceTrack(i, 5, 0.8, TO_TOON_BLDG_TIME * 0.1, slowInitBounce=0.0))
hideTrack.append(self.createBounceTrack(i, 7, 1.2, TO_TOON_BLDG_TIME * 0.17, slowInitBounce=0.0))
hideTrack.append(self.createBounceTrack(i, 9, 1.2, TO_TOON_BLDG_TIME * 0.18, slowInitBounce=0.0))
realScale = i.getScale()
hideTrack.append(LerpScaleInterval(i, TO_TOON_BLDG_TIME * 0.1, Vec3(realScale[0], realScale[1], 0.01)))
if landmark:
hideTrack.append(Func(i.removeNode))
else:
hideTrack.append(Func(i.stash))
hideTrack.append(Func(i.setScale, Vec3(1)))
if not suitSoundPlayed:
suitSoundPlayed = 1
tracks.append(hideTrack)
elif name[0] == 't':
hideTrack = Sequence(name=self.taskName('ToToonFlatsTrack'))
hideTrack.append(Wait(TO_TOON_BLDG_TIME * 0.5))
if not toonSoundPlayed:
hideTrack.append(Func(base.playSfx, self.toonGrowSound, 0, 1, None, 0.0))
hideTrack.append(Func(i.unstash))
hideTrack.append(Func(i.setScale, Vec3(1, 1, 0.01)))
if not toonSoundPlayed:
hideTrack.append(Func(base.playSfx, self.toonSettleSound, 0, 1, None, 0.0))
hideTrack.append(self.createBounceTrack(i, 11, 1.2, TO_TOON_BLDG_TIME * 0.5, slowInitBounce=4.0))
tracks.append(hideTrack)
if not toonSoundPlayed:
toonSoundPlayed = 1
self.stopTransition()
bldgMTrack = tracks
localToonIsVictor = self.localToonIsVictor()
if localToonIsVictor:
base.localAvatar.loop('neutral')
camTrack = self.walkOutCameraTrack()
victoryRunTrack, delayDeletes = self.getVictoryRunTrack()
trackName = self.taskName('toToonTrack')
self._deleteTransitionTrack()
if localToonIsVictor:
freedomTrack1 = Func(self.cr.playGame.getPlace().fsm.request, 'walk')
freedomTrack2 = Func(base.localAvatar.d_setParent, CIGlobals.SPRender)
self.transitionTrack = Parallel(camTrack, Sequence(victoryRunTrack, bldgMTrack, freedomTrack1, freedomTrack2), name=trackName)
else:
self.transitionTrack = Sequence(victoryRunTrack, bldgMTrack, name=trackName)
self.transitionTrack.delayDeletes = delayDeletes
if localToonIsVictor:
self.transitionTrack.start(0)
else:
self.transitionTrack.start(timeStamp)
return
def getSprayTrack(self,
origin,
target,
scaleUp,
hold,
scaleDown,
horizScale=1.0,
vertScale=1.0):
if self.sprayJoint.isEmpty():
self.build()
self.origin = self.getSprayStartPos()
base.localAvatar.stop(self.toonAnim)
self.lastFrame = self.avatar.getCurrentFrame(self.toonAnim)
track = Sequence()
sprayProp = loader.loadModel(GagGlobals.SPRAY_MDL)
sprayProp.setTwoSided(1)
sprayScale = hidden.attachNewNode('spray-parent')
sprayRot = hidden.attachNewNode('spray-rotate')
sprayRot.setColor(GagGlobals.WATER_SPRAY_COLOR)
sprayRot.setTransparency(1)
collNode = CollisionNode('Collision')
spraySphere = CollisionSphere(0, 0, 0, 1)
spraySphere.setTangible(0)
collNode.addSolid(spraySphere)
collNode.setCollideMask(CIGlobals.WallBitmask)
sprayNP = sprayRot.attachNewNode(collNode)
sprayNP.setY(1)
self.sprayNP = sprayNP
event = CollisionHandlerEvent()
event.set_in_pattern('%fn-into')
event.set_out_pattern('%fn-out')
base.cTrav.add_collider(sprayNP, event)
self.avatar.acceptOnce(sprayNP.node().getName() + '-into',
self.onCollision)
def showSpray(sprayScale, sprayProp, origin, target):
objects = [sprayRot, sprayScale, sprayProp]
for item in objects:
index = objects.index(item)
if index == 0:
item.reparentTo(self.sprayJoint)
item.setPos(0, 0, 0)
item.setHpr(self.sprayRotation)
item.wrtReparentTo(render)
else:
item.reparentTo(objects[index - 1])
track.append(Func(showSpray, sprayScale, sprayProp, origin, target))
self.spray = sprayRot
def calcTargetScale():
distance = Vec3(target - origin).length()
yScale = distance / GagGlobals.SPRAY_LEN
targetScale = Point3(yScale * horizScale, yScale,
yScale * vertScale)
return targetScale
track.append(
Parallel(
LerpScaleInterval(sprayScale,
scaleUp,
calcTargetScale,
startScale=GagGlobals.PNT3NEAR0),
sprayNP.posInterval(
0.25,
self.spray.getPos(render) + Point3(0, 50, 0),
startPos=self.spray.getPos(render) + Point3(0, 5, 0))))
track.append(Wait(hold))
track.append(Func(self.handleMiss))
track.append(LerpScaleInterval(sprayScale, 0.75, GagGlobals.PNT3NEAR0))
def hideSpray():
(lambda prop: prop.removeNode(), [sprayProp, sprayRot, sprayScale])
track.append(Func(hideSpray))
track.append(Func(self.completeSquirt))
return track
class DistributedCameraShyGame(DistributedMinigame):
notify = directNotify.newCategory("DistributedCameraShyGame")
def __init__(self, cr):
try:
self.DistributedCameraShyGame_initialized
return
except:
self.DistributedCameraShyGame_initialized = 1
DistributedMinigame.__init__(self, cr)
self.headPanels.delete()
self.headPanels = CameraShyHeadPanels()
self.fsm.addState(
State('countdown', self.enterCountdown, self.exitCountdown,
['play']))
self.fsm.addState(
State('announceGameOver', self.enterAnnounceGameOver,
self.exitAnnounceGameOver, ['showWinner']))
self.fsm.addState(
State('showWinner', self.enterShowWinner, self.exitShowWinner,
['gameOver']))
self.fsm.getStateNamed('waitForOthers').addTransition('countdown')
self.fsm.getStateNamed('play').addTransition('announceGameOver')
self.remoteAvatars = []
self.myRemoteAvatar = None
self.thisPlayerWinsLbl = None
self.olc = None
self.firstPerson = CameraShyFirstPerson(self)
self.skyUtil = None
self.pbpText = None
self.levelLoader = CameraShyLevelLoader()
self.spawnPoints = []
def setLevel(self, level):
self.levelLoader.setLevel(level)
def generateOtherPlayerGui(self):
self.headPanels.generateOtherPlayerGui()
def updateOtherPlayerHead(self, avId, otherAvId, state):
self.headPanels.updateOtherPlayerHead(avId, otherAvId, state)
def getPlayByPlayText(self):
return OnscreenText(text="",
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, 1),
pos=(0, 0.75))
def removePlayByPlay(self):
if self.pbpText:
taskMgr.remove('DCameraShyGame-removePlayByPlay')
self.pbpText.destroy()
self.pbpText = None
def removePlayByPlayTask(self, task):
self.removePlayByPlay()
return Task.done
def showPlayByPlay(self, situation, avId):
self.removePlayByPlay()
av = self.cr.doId2do.get(avId)
name = av.getName()
if situation == 0:
self.pbpText = self.getPlayByPlayText()
self.pbpText.setText("{0} took a picture of you!".format(name))
taskMgr.doMethodLater(3.0, self.removePlayByPlayTask,
"DCameraShyGame-removePlayByPlay")
def tookPictureOfMe(self, avId):
self.headPanels.hideFrames()
self.firstPerson.stopCameraFlash()
base.transitions.setFadeColor(1, 1, 1)
base.transitions.fadeOut(0.1)
self.showPlayByPlay(0, avId)
Sequence(Wait(1), Func(self.respawn)).start()
def respawn(self):
base.transitions.fadeIn()
pos, hpr = self.pickSpawnPoint()
base.localAvatar.setPos(pos)
base.localAvatar.setHpr(hpr - (180, 0, 0))
base.localAvatar.d_broadcastPositionNow()
Sequence(Wait(0.6), Func(self.headPanels.showFrames),
Func(base.transitions.setFadeColor, 0, 0, 0)).start()
def announceGameOver(self):
self.fsm.request('announceGameOver')
def showWinner(self, avId):
base.transitions.fadeOut()
Sequence(Wait(0.51), Func(self.fsm.request, 'showWinner',
[avId])).start()
#self.fsm.request('showWinner', [avId])
def enterGameOver(self, winner, winnerDoId, allPrize):
try:
currentCamPos = base.camera.getPos(render)
currentCamHpr = base.camera.getHpr(render)
self.firstPerson.reallyEnd()
base.camera.setPos(currentCamPos)
base.camera.setHpr(currentCamHpr)
except:
pass
DistributedMinigame.enterGameOver(self, winner, winnerDoId, allPrize)
def enterShowWinner(self, winnerId):
self.firstPerson.reallyEnd()
avatar = self.getRemoteAvatar(winnerId)
avatar.avatar.loop('neutral')
avatar.detachCamera()
self.thisPlayerWinsLbl = OnscreenText(text="{0} Wins!".format(
avatar.avatar.getName()),
fg=(1, 1, 1, 1),
font=CIGlobals.getMinnieFont(),
pos=(0, 0.8),
scale=0.1)
if winnerId == base.localAvatar.doId:
self.thisPlayerWinsLbl.setText("You Win!")
base.camera.reparentTo(avatar.avatar)
base.camera.setPos(0, 7, 3)
base.camera.setH(180)
base.transitions.fadeIn()
Sequence(Wait(0.5), Func(avatar.doWinDance)).start()
def exitShowWinner(self):
pass
def enterAnnounceGameOver(self):
whistle = base.loadSfx("phase_4/audio/sfx/AA_sound_whistle.ogg")
base.playSfx(whistle)
self.gameOverLbl = OnscreenText(text='Game Over!',
fg=(1, 1, 1, 1),
font=CIGlobals.getMinnieFont(),
scale=0.1)
self.gameOverScaleIval = LerpScaleInterval(self.gameOverLbl,
duration=1.0,
scale=0.1,
startScale=0.0,
blendType='easeOut')
#self.gameOverScaleIval.start()
def exitAnnounceGameOver(self):
self.gameOverScaleIval.finish()
del self.gameOverScaleIval
self.gameOverLbl.destroy()
del self.gameOverLbl
def remoteAvatarTakePicture(self, avId):
avatar = self.getRemoteAvatar(avId)
if avatar:
avatar.takePicture()
def createRemoteAvatar(self, avId):
if avId == base.localAvatar.doId:
self.myRemoteAvatar = RemoteCameraShyAvatar(self, self.cr, avId)
self.remoteAvatars.append(self.myRemoteAvatar)
else:
av = RemoteCameraShyAvatar(self, self.cr, avId)
self.remoteAvatars.append(av)
def getRemoteAvatar(self, avId):
for avatar in self.remoteAvatars:
if avatar.avId == avId:
return avatar
def allPlayersReady(self):
self.fsm.request('countdown')
def enterCountdown(self):
base.localAvatar.chatInput.disableKeyboardShortcuts()
base.localAvatar.disableChatInput()
base.setBackgroundColor(CIGlobals.DefaultBackgroundColor)
base.render.show()
self.playMinigameMusic()
self.countdownLbl = OnscreenText(text="",
fg=(1, 1, 1, 1),
font=CIGlobals.getMinnieFont(),
scale=0.1)
self.countdownTrack = Sequence(Func(self.countdownLbl.setText, "5"),
Wait(1.0),
Func(self.countdownLbl.setText, "4"),
Wait(1.0),
Func(self.countdownLbl.setText, "3"),
Wait(1.0),
Func(self.countdownLbl.setText, "2"),
Wait(1.0),
Func(self.countdownLbl.setText, "1"),
Wait(1.0), Func(self.fsm.request,
"play"))
self.countdownTrack.start()
self.firstPerson.start()
self.firstPerson.disableMouse()
def exitCountdown(self):
if hasattr(self, 'countdownTrack'):
self.countdownTrack.pause()
del self.countdownTrack
if hasattr(self, 'countdownLbl'):
self.countdownLbl.destroy()
del self.countdownLbl
def enterPlay(self):
self.createTimer()
self.firstPerson.reallyStart()
def exitPlay(self):
self.firstPerson.end()
self.firstPerson.enableMouse()
self.deleteTimer()
DistributedMinigame.exitPlay(self)
def createWorld(self):
self.levelLoader.load()
self.spawnPoints = self.levelLoader.getSpawnPoints()
def pickSpawnPoint(self):
return random.choice(self.spawnPoints)
def setSpawnPoint(self, index):
pos, hpr = self.spawnPoints[index]
base.localAvatar.setPos(pos)
base.localAvatar.setHpr(hpr)
def load(self):
self.createWorld()
self.setMinigameMusic("phase_6/audio/bgm/GS_Race_SS.ogg")
self.setDescription("Be the first to take 3 pictures of all the other Toons with your camera. " + \
"Use WASD to move and the mouse to look around. Press the left mouse button to take a picture. " + \
"Your camera takes some time to recharge after taking a picture. " + \
"You know you have a good shot when the view finder is green!")
self.setWinnerPrize(150)
self.setLoserPrize(15)
base.render.hide()
base.setBackgroundColor(0, 0, 0)
DistributedMinigame.load(self)
def announceGenerate(self):
base.camLens.setMinFov(CIGlobals.GunGameFOV / (4. / 3.))
self.load()
DistributedMinigame.announceGenerate(self)
def disable(self):
if self.thisPlayerWinsLbl:
self.thisPlayerWinsLbl.destroy()
self.thisPlayerWinsLbl = None
base.camera.reparentTo(render)
base.camera.setPos(0, 0, 0)
base.camera.setHpr(0, 0, 0)
if self.myRemoteAvatar:
self.myRemoteAvatar.cleanup()
del self.myRemoteAvatar
self.firstPerson.cleanup()
del self.firstPerson
self.levelLoader.unload()
self.levelLoader.cleanup()
del self.levelLoader
base.camLens.setMinFov(CIGlobals.DefaultCameraFov / (4. / 3.))
DistributedMinigame.disable(self)
def equip(self):
if not BaseHitscan.equip(self):
return False
self.sprayParticleRoot = render.attachNewNode('sprayParticleRoot')
self.sprayParticleRoot.setLightOff(1)
self.sprayParticleRoot.hide(CIGlobals.ShadowCameraBitmask)
if self.isLocal():
self.released = True
self.waterBar = WaterBar()
self.__updateWaterBar()
self.waterBar.reparentTo(base.a2dLeftCenter)
self.waterBar.setScale(0.6)
self.waterBar.setX(0.166)
self.hydrant = loader.loadModel('phase_5/models/props/battle_hydrant.bam')
self.model.reparentTo(self.hydrant)
self.model.pose('chan', 2)
self.hoseJoint = self.model.controlJoint(None, "modelRoot", "joint_x")
self.hydrantNode = self.avatar.attachNewNode('hydrantNode')
self.hydrantNode.clearTransform(self.avatar.getGeomNode().getChild(0))
self.hydrantNode.setHpr(0, 0, 0)
self.hydrantScale = self.hydrantNode.attachNewNode('hydrantScale')
self.hydrant.reparentTo(self.hydrantScale)
self.avatar.pose('firehose', 30)
self.avatar.update(0)
torso = self.avatar.getPart('torso')
if 'dgm' in self.avatar.getTorso():
self.hydrant.setPos(torso, 0, 0, -1.85)
else:
self.hydrant.setPos(torso, 0, 0, -1.45)
hbase = self.hydrant.find('**/base')
hbase.setColor(1, 1, 1, 0.5)
hbase.setPos(self.avatar, 0, 0, 0)
self.avatar.loop('neutral')
tAppearDelay = 0.7
dAnimHold = 5.1
dHoseHold = 0.7
tSprayDelay = 2.8
track = Parallel()
toonTrack = Sequence(Wait(tAppearDelay),
Func(self.avatar.setForcedTorsoAnim, 'firehose'),
self.getAnimationTrack('firehose', endFrame = 30),
Func(self.__doBob))
propTrack = Sequence(Func(self.hydrantNode.reparentTo, self.avatar), LerpScaleInterval(self.hydrantScale, tAppearDelay * 0.5, Point3(1, 1, 1.4),
startScale=Point3(1, 1, 0.01)), LerpScaleInterval(self.hydrantScale, tAppearDelay * 0.3, Point3(1, 1, 0.8), startScale=Point3(1, 1, 1.4)),
LerpScaleInterval(self.hydrantScale, tAppearDelay * 0.1, Point3(1, 1, 1.2), startScale=Point3(1, 1, 0.8)),
LerpScaleInterval(self.hydrantScale, tAppearDelay * 0.1, Point3(1, 1, 1), startScale=Point3(1, 1, 1.2)),
ActorInterval(self.model, 'chan', endFrame = 30))
track.append(toonTrack)
track.append(propTrack)
self.setAnimTrack(track, startNow = True)
if self.isFirstPerson():
self.hydrantNode.hide()
return True
def initIntervals(self):
self.baseSpinDuration = 1.0
self.propellerSpinLerp = LerpFunctionInterval(
self.propeller.setH,
fromData=0.0,
toData=360.0,
duration=self.baseSpinDuration,
name='%s.propellerSpinLerp-%s' %
(self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.TargetedWarningSingleBlinkTime
blinkTime = Globals.Gameplay.TargetedWarningBlinkTime
self.blinkLoop = Sequence(
Wait(singleBlinkTime / 2.0),
Func(self.setBackpackTexture,
Globals.Gameplay.BackpackStates.Attacked),
Wait(singleBlinkTime / 2.0),
Func(self.setBackpackTexture,
Globals.Gameplay.BackpackStates.Targeted),
name='%s.blinkLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkWarningSeq = Sequence(
Func(self.blinkLoop.loop),
Wait(blinkTime),
Func(self.blinkLoop.clearToInitial),
name='%s.blinkWarningSeq-%s' %
(self.__class__.__name__, self.toon.doId))
dur = Globals.Gameplay.BackpackRefuelDuration
self.refuelSeq = Sequence(
Func(self.setPropellerSpinRate, Globals.Gameplay.RefuelPropSpeed),
Wait(dur),
Func(self.returnBackpackToLastStateFunc),
name='%s.refuelSeq-%s' % (self.__class__.__name__, self.toon.doId))
scale = self.redTapeRing.getScale()
pulseTime = 1.0
self.pulseBubbleSeq = Parallel(
Sequence(
LerpFunctionInterval(self.redTapeRing.setScale,
fromData=scale,
toData=scale * 1.1,
duration=pulseTime / 2.0,
blendType='easeInOut'),
LerpFunctionInterval(self.redTapeRing.setScale,
fromData=scale * 1.1,
toData=scale,
duration=pulseTime / 2.0,
blendType='easeInOut')),
LerpHprInterval(self.redTapeRing,
pulseTime,
Vec3(360, 0, 0),
startHpr=Vec3(0, 0, 0)),
name='%s.pulseBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
bouncePercent = 1.2
scaleTime = 0.5
scaleBounceTime = 0.25
self.popUpBubbleLerp = LerpScaleInterval(self.redTapeRing,
scaleTime,
scale * bouncePercent,
startScale=0.0,
blendType='easeInOut')
self.popUpBubbleSeq = Sequence(
Func(self.updateLerpStartScale, self.popUpBubbleLerp,
self.redTapeRing),
Func(self.redTapeRing.show),
self.popUpBubbleLerp,
LerpScaleInterval(self.redTapeRing,
scaleBounceTime,
scale,
startScale=scale * bouncePercent,
blendType='easeInOut'),
Func(self.pulseBubbleSeq.loop),
name='%s.popUpBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
self.removeBubbleLerp = LerpScaleInterval(self.redTapeRing,
scaleBounceTime,
scale * bouncePercent,
startScale=scale,
blendType='easeInOut')
self.removeBubbleSeq = Sequence(
Func(self.pulseBubbleSeq.clearToInitial),
Func(self.updateLerpStartScale, self.removeBubbleLerp,
self.redTapeRing),
self.removeBubbleLerp,
LerpScaleInterval(self.redTapeRing,
scaleTime,
0.0,
startScale=scale * bouncePercent,
blendType='easeInOut'),
Func(self.redTapeRing.hide),
name='%s.removeBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
self.redTapeRing.setScale(0.0)
self.deathInterval = Sequence(
Parallel(
LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)),
LerpFunctionInterval(self.toon.setScale,
fromData=1.0,
toData=0.1,
duration=1.0)),
Func(self.toon.stash),
name='%s.deathInterval-%s' %
(self.__class__.__name__, self.toon.doId))
self.spawnInterval = Sequence(
Func(self.toon.stash),
Func(self.resetToon),
Wait(1.0),
Func(self.toon.setAnimState, 'TeleportIn'),
Func(self.toon.unstash),
name='%s.spawnInterval-%s' %
(self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.InvulSingleBlinkTime
blinkTime = Globals.Gameplay.InvulBlinkTime
invulBuffTime = Globals.Gameplay.InvulBuffTime
self.blinkBubbleLoop = Sequence(
LerpFunctionInterval(self.redTapeRing.setAlphaScale,
fromData=1.0,
toData=0.0,
duration=singleBlinkTime / 2.0,
blendType='easeInOut'),
LerpFunctionInterval(self.redTapeRing.setAlphaScale,
fromData=0.0,
toData=1.0,
duration=singleBlinkTime / 2.0,
blendType='easeInOut'),
name='%s.blinkBubbleLoop-%s' %
(self.__class__.__name__, self.toon.doId))
self.blinkBubbleSeq = Sequence(
Wait(invulBuffTime - blinkTime),
Func(self.blinkBubbleLoop.loop),
Wait(blinkTime),
Func(self.blinkBubbleLoop.finish),
name='%s.blinkBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
def setEveryoneDone(self):
if not self.hasLocalToon: return
if self.gameFSM.getCurrentState().getName() != 'play':
self.notify.warning('ignoring setEveryoneDone msg')
return
self.notify.debug('setEveryoneDone')
def endGame(task, self=self):
if not PairingGameGlobals.EndlessGame:
self.gameOver()
return Task.done
# hide the timer
self.timer.hide()
# hide the bonus
self.bonusGlow.hide()
# if it was a perfect game, let the players know
if len(self.inactiveList) == len(self.cards):
self.notify.debug("perfect game!")
perfectTextSubnode = hidden.attachNewNode(
self.__genText(TTLocalizer.PairingGamePerfect))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
# offset the subnode so that the text is centered on both axes
# we need the parent node so that the text will scale correctly
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, .1, .1, 1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text=perfectText):
text.removeNode()
textTrack = Sequence(
Func(perfectText.reparentTo, aspect2d),
Parallel(
LerpScaleInterval(perfectText,
duration=.5,
scale=.3,
startScale=0.),
LerpFunctionInterval(
fadeFunc,
fromData=0.,
toData=1.,
duration=.5,
)),
Wait(2.),
Parallel(
LerpScaleInterval(perfectText, duration=.5, scale=1.),
LerpFunctionInterval(fadeFunc,
fromData=1.,
toData=0.,
duration=.5,
blendType="easeIn"),
),
Func(destroyText),
WaitInterval(.5),
Func(endGame, None),
)
soundTrack = SoundInterval(self.sndPerfect)
self.perfectIval = Parallel(textTrack, soundTrack)
self.perfectIval.start()
else:
taskMgr.doMethodLater(1, endGame, self.EndGameTaskName)
def doSplat(self):
if self.splatTrack and self.splatTrack.isPlaying():
self.splatTrack.finish()
self.splat.reparentTo(render)
self.splat.setPos(self.object, 0, 0, 3.0)
self.splat.setY(self.splat.getY() - 1.0)
self._splatSfxIval.node = self.splat
self.splatTrack = Parallel(self._splatSfxIval, Sequence(Func(self.splat.showThrough), LerpScaleInterval(self.splat, duration=0.5, scale=6, startScale=1, blendType='easeOut'), Func(self.splat.hide)))
self.splatTrack.start()
def showGrab(self):
self.nodePath.hide()
self.collNodePath.hide()
self.collNode.setIntoCollideMask(BitMask32(0))
if self.penalty:
self.track = Parallel(SoundInterval(self.penaltyGrabSound), Sequence(Func(self.kaboom.showThrough), LerpScaleInterval(self.kaboom, duration=0.5, scale=Point3(10, 10, 10), blendType='easeOut'), Func(self.kaboom.hide)))
self.track.start()
def showKaboom(self):
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.kaboom.reparentTo(render)
self.kaboom.setPos(self.suit.getPos())
self.kaboom.setZ(3)
self.kaboomTrack = Parallel(SoundInterval(self.kaboomSound, volume=0.5), Sequence(Func(self.kaboom.showThrough), LerpScaleInterval(self.kaboom, duration=0.5, scale=Point3(10, 10, 10), startScale=Point3(1, 1, 1), blendType='easeOut'), Func(self.kaboom.hide)))
self.kaboomTrack.start()
class Droppable:
"""An object that can be dropped onto. (Part of the Drag & Drop protocol.)
Initially droppable is disabled, users must call set_droppable(True) to
enable it.
"""
def __init__(self):
pass
def drop(self,event):
"""A draggable has been dropped onto this droppable.
Subclasses should extend this if they want to do something."""
# Finish any intervals that are playing.
# FIXME: this tightly couples Droppable to Highlightable. Move this code
# into highlightable.
if hasattr(self,'scaleDownInterval') and self.scaleDownInterval.isPlaying():
self.scaleDownInterval.finish()
elif hasattr(self,'scaleUpInterval') and self.scaleUpInterval.isPlaying():
self.scaleUpInterval.finish()
# Reset the scale.
if hasattr(self,'prevScale'):
self.setScale(self.prevScale)
def set_droppable(self,b):
"""Enable or disable dropping onto the NodePath."""
# FIXME: move this into Highlightable.
# Finish any intervals that are playing.
if hasattr(self,'scaleDownInterval') and self.scaleDownInterval.isPlaying():
self.scaleDownInterval.finish()
elif hasattr(self,'scaleUpInterval') and self.scaleUpInterval.isPlaying():
self.scaleUpInterval.finish()
# Reset the scale.
if hasattr(self,'prevScale'):
self.setScale(self.prevScale)
if b is True:
self.np.setPythonTag('droppable',self)
else:
self.np.clearPythonTag('droppable')
def highlight(self):
"""Subclasses should override this method to implement custom drag-over
behaviour."""
# If we are already scaling up, do nothing.
if hasattr(self,'scaleUpInterval') and self.scaleUpInterval.isPlaying():
return
# If we are in the process of scaling down, finish it off immediately.
if hasattr(self,'scaleDownInterval') and self.scaleDownInterval.isPlaying():
self.scaleDownInterval.finish()
from direct.interval.IntervalGlobal import LerpScaleInterval
self.prevScale = self.getScale()
self.scaleUpInterval = LerpScaleInterval(self.np, duration=0.2, scale=self.getScale()*1.2, startScale=self.getScale())
self.scaleUpInterval.start()
def unhighlight(self):
"""Subclasses should override this method to implement custom drag-over
behaviour."""
# If we are already scaling down, do nothing.
if hasattr(self,'scaleDownInterval') and self.scaleDownInterval.isPlaying():
return
# If we are in the process of scaling up, stop.
if hasattr(self,'scaleUpInterval') and self.scaleUpInterval.isPlaying():
self.scaleUpInterval.pause()
from direct.interval.IntervalGlobal import LerpScaleInterval
self.scaleDownInterval = LerpScaleInterval(self.np, duration=0.2, scale=self.prevScale, startScale=self.getScale())
self.scaleDownInterval.start()
def showSplat(self):
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.splat.reparentTo(render)
self.splat.setPos(self.suit.getPos())
self.splat.setZ(3)
self.kaboomTrack = Parallel(SoundInterval(self.pieHitSound, volume=1.0), Sequence(Func(self.splat.showThrough), LerpScaleInterval(self.splat, duration=0.5, scale=1.75, startScale=Point3(0.1, 0.1, 0.1), blendType='easeOut'), Func(self.splat.hide)))
self.kaboomTrack.start()
def makeToonGrabInterval(self, toon):
toon.pose('leverNeutral', 0)
toon.update()
rightHandPos = toon.rightHand.getPos(toon)
self.toonPitcherPosition = Point3(self.handPos[0] - rightHandPos[0], self.handPos[1] - rightHandPos[1], 0)
destZScale = rightHandPos[2] / self.handPos[2]
grabIval = Sequence(Func(toon.wrtReparentTo, self.waterPitcherNode), Func(toon.loop, 'neutral'), Parallel(ActorInterval(toon, 'jump'), Sequence(Wait(0.43), Parallel(ProjectileInterval(toon, duration=0.9, startPos=toon.getPos(self.waterPitcherNode), endPos=self.toonPitcherPosition), LerpHprInterval(toon, 0.9, Point3(0, 0, 0)), LerpScaleInterval(self.waterPitcherModel, 0.9, Point3(1, 1, destZScale))))), Func(toon.setPos, self.toonPitcherPosition), Func(toon.loop, 'leverNeutral'))
return grabIval
def enterShowScores(self):
self.notify.debug('enterShowScores')
lerpTrack = Parallel()
lerpDur = 0.5
lerpTrack.append(Parallel(LerpPosInterval(self.goalBar, lerpDur, Point3(0, 0, -.6), blendType='easeInOut'), LerpScaleInterval(self.goalBar, lerpDur, Vec3(self.goalBar.getScale()) * 2.0, blendType='easeInOut')))
tY = 0.6
bY = -.05
lX = -.5
cX = 0
rX = 0.5
scorePanelLocs = (((cX, bY),),
((lX, bY), (rX, bY)),
((cX, tY), (lX, bY), (rX, bY)),
((lX, tY),
(rX, tY),
(lX, bY),
(rX, bY)))
scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
panel.wrtReparentTo(aspect2d)
lerpTrack.append(Parallel(LerpPosInterval(panel, lerpDur, Point3(pos[0], 0, pos[1]), blendType='easeInOut'), LerpScaleInterval(panel, lerpDur, Vec3(panel.getScale()) * 2.0, blendType='easeInOut')))
self.showScoreTrack = Parallel(lerpTrack, Sequence(Wait(MazeGameGlobals.SHOWSCORES_DURATION), Func(self.gameOver)))
self.showScoreTrack.start()
#For the Alpha Blueprint ARG
if base.config.GetBool('want-blueprint4-ARG', False):
MinigameGlobals.generateDebugARGPhrase()
def getSprayTrack(self,
color,
origin,
target,
dScaleUp,
dHold,
dScaleDown,
horizScale=1.0,
vertScale=1.0,
parent=render):
track = Sequence()
SPRAY_LEN = 1.5
sprayProp = MovieUtil.globalPropPool.getProp('spray')
sprayScale = hidden.attachNewNode('spray-parent')
sprayRot = hidden.attachNewNode('spray-rotate')
spray = sprayRot
spray.setColor(color)
if color[3] < 1.0:
spray.setTransparency(1)
def showSpray(sprayScale, sprayRot, sprayProp, origin, target, parent):
if callable(origin):
origin = origin()
if callable(target):
target = target()
sprayRot.reparentTo(parent)
sprayRot.clearMat()
sprayScale.reparentTo(sprayRot)
sprayScale.clearMat()
sprayProp.reparentTo(sprayScale)
sprayProp.clearMat()
sprayRot.setPos(origin)
sprayRot.lookAt(Point3(target))
track.append(
Func(showSpray, sprayScale, sprayRot, sprayProp, origin, target,
parent))
def calcTargetScale(target=target,
origin=origin,
horizScale=horizScale,
vertScale=vertScale):
if callable(target):
target = target()
if callable(origin):
origin = origin()
distance = Vec3(target - origin).length()
yScale = distance / SPRAY_LEN
targetScale = Point3(yScale * horizScale, yScale,
yScale * vertScale)
return targetScale
track.append(
LerpScaleInterval(sprayScale,
dScaleUp,
calcTargetScale,
startScale=Point3(0.01, 0.01, 0.01)))
track.append(Func(self.checkHitObject))
track.append(Wait(dHold))
def prepareToShrinkSpray(spray, sprayProp, origin, target):
if callable(target):
target = target()
if callable(origin):
origin = origin()
sprayProp.setPos(Point3(0.0, -SPRAY_LEN, 0.0))
spray.setPos(target)
track.append(
Func(prepareToShrinkSpray, spray, sprayProp, origin, target))
track.append(
LerpScaleInterval(sprayScale, dScaleDown, Point3(0.01, 0.01,
0.01)))
def hideSpray(spray, sprayScale, sprayRot, sprayProp, propPool):
sprayProp.detachNode()
MovieUtil.removeProp(sprayProp)
sprayRot.removeNode()
sprayScale.removeNode()
track.append(
Func(hideSpray, spray, sprayScale, sprayRot, sprayProp,
MovieUtil.globalPropPool))
return track
def getDropIval(self):
shadow = self.shadow
drop = self.drop
id = self.id
hangTime = Globals.ShadowTime
dropTime = Globals.DropTime
dropHeight = Globals.DropHeight
targetShadowScale = 0.5
targetShadowAlpha = 0.4
shadowScaleIval = LerpScaleInterval(shadow,
dropTime,
targetShadowScale,
startScale=0)
shadowAlphaIval = LerpColorScaleInterval(
shadow,
hangTime,
Point4(1, 1, 1, targetShadowAlpha),
startColorScale=Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
startPos = Point3(0, 0, dropHeight)
drop.setPos(startPos)
dropIval = LerpPosInterval(drop,
dropTime,
Point3(0, 0, 0),
startPos=startPos,
blendType='easeIn')
dropSoundIval = self._dropSfx
dropSoundIval.node = self
self.drop.setTransparency(1)
def _setRandScale(t):
self.drop.setScale(self, 1 - random.random() / 16,
1 - random.random() / 16,
1 - random.random() / 4)
scaleChange = 0.4 + random.random() / 4
dropShakeSeq = Sequence(
LerpScaleInterval(self.drop,
0.25,
Vec3(1.0 + scaleChange, 1.0 + scaleChange / 2,
1.0 - scaleChange),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.25,
Vec3(1.0, 1.0, 1.0),
blendType='easeInOut'),
Func(self.disableCollisionDamage),
LerpScaleInterval(self.drop,
0.2,
Vec3(1.0 + scaleChange / 8,
1.0 + scaleChange / 8,
1.0 - scaleChange / 8),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.2,
Vec3(1.0, 1.0, 1.0),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.15,
Vec3(1.0 + scaleChange / 16,
1.0 + scaleChange / 16,
1.0 - scaleChange / 16),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.15,
Vec3(1.0, 1.0, 1.0),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.1,
Vec3(1.0 + scaleChange / 16,
1.0 + scaleChange / 8,
1.0 - scaleChange / 16),
blendType='easeInOut'),
LerpColorScaleInterval(self.drop, Globals.DropFadeTime,
Vec4(1.0, 1.0, 1.0, 0.0)))
ival = Sequence(Func(self.reparentTo, render),
Parallel(Sequence(WaitInterval(hangTime), dropIval),
shadowIval),
Parallel(Func(self.game.dropHit, self, id),
dropSoundIval, dropShakeSeq),
Func(self.game.cleanupDrop, id),
name='drop%s' % id)
self.ival = ival
return ival
def getPulseIval(self, node, scale = 1, duration = 0.25):
return Sequence(LerpScaleInterval(node, duration, scale * 1.1, 0.001, blendType = 'easeOut'), LerpScaleInterval(node, duration / 2.0, scale))
class FountainPenAttack(Attack):
notify = directNotify.newCategory('FountainPenAttack')
attack = 'fountainpen'
def __init__(self, attacksClass, suit):
Attack.__init__(self, attacksClass, suit)
self.pen = None
self.spray = None
self.splat = None
self.spraySfx = None
self.sprayParticle = None
self.sprayScaleIval = None
self.wsnp = None
return
def loadAttack(self):
self.pen = loader.loadModel('phase_5/models/props/pen.bam')
self.pen.reparentTo(self.suit.find('**/joint_Rhold'))
self.sprayParticle = ParticleLoader.loadParticleEffect('phase_5/etc/penSpill.ptf')
self.spray = loader.loadModel('phase_3.5/models/props/spray.bam')
self.spray.setColor(VBase4(0, 0, 0, 1))
self.splat = Actor('phase_3.5/models/props/splat-mod.bam', {'chan': 'phase_3.5/models/props/splat-chan.bam'})
self.splat.setColor(VBase4(0, 0, 0, 1))
self.sprayScaleIval = LerpScaleInterval(self.spray, duration=0.3, scale=(1,
20,
1), startScale=(1,
1,
1))
sphere = CollisionSphere(0, 0, 0, 0.5)
sphere.setTangible(0)
if hasattr(self.suit, 'uniqueName'):
collName = self.suit.uniqueName('fountainPenCollNode')
else:
collName = 'fountainPenCollNode'
collNode = CollisionNode(collName)
collNode.addSolid(sphere)
collNode.setCollideMask(CIGlobals.WallBitmask)
self.wsnp = self.spray.attachNewNode(collNode)
self.wsnp.setY(1)
def doAttack(self, ts=0):
self.loadAttack()
if hasattr(self.suit, 'uniqueName'):
name = self.suit.uniqueName('doFountainPenAttack')
else:
name = 'doFountainPenAttack'
self.suitTrack = Parallel(name=name)
self.suitTrack.append(ActorInterval(self.suit, 'fountainpen'))
self.suitTrack.append(Sequence(Wait(1.2), Func(self.acceptOnce, 'enter' + self.wsnp.node().getName(), self.handleSprayCollision), Func(self.playWeaponSound), Func(self.attachSpray), Func(self.sprayParticle.start, self.pen.find('**/joint_toSpray'), self.pen.find('**/joint_toSpray')), self.sprayScaleIval, Wait(0.5), Func(self.sprayParticle.cleanup), Func(self.spray.setScale, 1), Func(self.spray.reparentTo, hidden), Func(self.ignore, 'enter' + self.wsnp.node().getName())))
self.suitTrack.setDoneEvent(self.suitTrack.getName())
self.acceptOnce(self.suitTrack.getDoneEvent(), self.finishedAttack)
self.suitTrack.delayDelete = DelayDelete.DelayDelete(self.suit, name)
self.suitTrack.start(ts)
def attachSpray(self):
self.spray.reparentTo(self.pen.find('**/joint_toSpray'))
pos = self.spray.getPos(render)
hpr = self.spray.getHpr(render)
self.spray.reparentTo(render)
self.spray.setPos(pos)
self.spray.setHpr(hpr)
self.spray.setP(0)
if self.suit.type == 'C':
self.spray.setH(self.spray.getH() + 7.5)
self.spray.setTwoSided(True)
def handleSprayCollision(self, entry):
if self.suit:
self.suit.sendUpdate('toonHitByWeapon', [self.getAttackId(self.attack), base.localAvatar.doId])
base.localAvatar.b_handleSuitAttack(self.getAttackId(self.attack), self.suit.doId)
self.sprayScaleIval.pause()
def playWeaponSound(self):
self.spraySfx = base.audio3d.loadSfx('phase_5/audio/sfx/SA_fountain_pen.ogg')
base.audio3d.attachSoundToObject(self.spraySfx, self.pen)
self.spraySfx.play()
def cleanup(self):
Attack.cleanup(self)
if self.wsnp:
self.wsnp.node().clearSolids()
self.wsnp.removeNode()
self.wsnp = None
if self.pen:
self.pen.removeNode()
self.pen = None
if self.sprayParticle:
self.sprayParticle.cleanup()
self.sprayParticle = None
if self.spray:
self.spray.removeNode()
self.spray = None
if self.splat:
self.splat.cleanup()
self.splat = None
if self.sprayScaleIval:
self.sprayScaleIval.pause()
self.sprayScaleIval = None
self.spraySfx = None
return
def start(self):
base.transitions.fadeOut(t=0)
self.setColorScale(Vec4(1, 1, 1, 1))
if self.fadeTrack is not None:
self.fadeTrack.finish()
self.fadeTrack = None
self.fadeTrack = base.transitions.getFadeInIval(t=2)
self.fadeTrack.start()
if self.logoScaleTrack is not None:
self.logoScaleTrack.finish()
self.logoScaleTrack = None
self.logoScaleTrack = Sequence(
LerpScaleInterval(self.logo,
2,
Vec3(1.1, 1, 0.55),
Vec3(1, 1, 0.5),
blendType='easeInOut'),
LerpScaleInterval(self.logo,
2,
Vec3(1, 1, 0.5),
Vec3(1.1, 1, 0.55),
blendType='easeInOut'))
if self.logoPosTrack is not None:
self.logoPosTrack.finish()
self.logoPosTrack = None
self.logoPosTrack = Sequence(
LerpPosInterval(self.logo,
2,
Point3(0, 0, -0.85),
Point3(0, 0, -0.7),
blendType='easeOut'),
Func(self.logoScaleTrack.loop))
self.logoPosTrack.start()
if self.labelColorScaleTrack is not None:
self.labelColorScaleTrack.finish()
self.labelColorScaleTrack = None
self.labelColorScaleTrack = Sequence(
LerpColorScaleInterval(self.label, 1, Vec4(1, 1, 1, 0.6),
Vec4(1, 1, 1, 1)),
LerpColorScaleInterval(self.label, 1, Vec4(1, 1, 1, 1),
Vec4(1, 1, 1, 0.6)))
if self.labelPosTrack is not None:
self.labelPosTrack.finish()
self.labelPosTrack = None
self.labelPosTrack = Sequence(
LerpPosInterval(self.label,
2,
Point3(0, 0, 0.35),
Point3(0, 0, 0.15),
blendType='easeOut'),
Func(self.labelColorScaleTrack.loop))
self.labelPosTrack.start()
self.acceptOnce('mouse1', self.begin)
def __center_view_on_objects(self, transition=True, obj_to_align_to=None, obj_id=None):
if self._lerp_interval:
return
from math import tan, radians
if obj_to_align_to:
objs = [obj_to_align_to]
elif obj_id:
obj = Mgr.get("object", obj_id)
objs = [obj]
else:
pixel_color = Mgr.get("pixel_under_mouse")
obj = Mgr.get("object", pixel_color=pixel_color)
if obj:
objs = [obj]
else:
selection = Mgr.get("selection_top")
if selection:
objs = selection
else:
objs = Mgr.get("objects")
if not objs:
return
obj_root = Mgr.get("object_root")
cam = self.cam
bounds_np = cam.origin.attach_new_node("cam_aligned_node")
tmp_np = bounds_np.attach_new_node("tmp_node")
if obj_to_align_to:
bounds_np.set_hpr(obj_to_align_to.get_pivot(), 0., 0., 0.)
parents = {}
parent_copies = {}
bboxes = dict((obj, obj.get_bbox()) for obj in objs if obj.get_type() == "model")
for bbox in bboxes.values():
bbox.get_origin().detach_node()
for obj in objs:
orig = obj.get_origin()
parent = orig.get_parent()
parents[orig] = parent
if parent in parent_copies:
parent_copy = parent_copies[parent]
else:
parent_copy = NodePath("parent_copy")
parent_copy.set_transform(parent.get_transform(self.world))
parent_copy.wrt_reparent_to(tmp_np)
parent_copies[parent] = parent_copy
orig.reparent_to(parent_copy)
bounds = tmp_np.get_tight_bounds()
for orig, parent in parents.items():
orig.reparent_to(parent)
for obj, bbox in bboxes.items():
bbox.get_origin().reparent_to(obj.get_origin())
centers = {}
for obj in objs:
center = obj.get_center_pos(tmp_np)
if centers:
centers["min"].x = min(centers["min"].x, center.x)
centers["min"].y = min(centers["min"].y, center.y)
centers["min"].z = min(centers["min"].z, center.z)
centers["max"].x = max(centers["max"].x, center.x)
centers["max"].y = max(centers["max"].y, center.y)
centers["max"].z = max(centers["max"].z, center.z)
else:
centers = {"min": center, "max": VBase3(center)}
if bounds:
point_min, point_max = bounds
point_min.x = min(point_min.x, centers["min"].x)
point_min.y = min(point_min.y, centers["min"].y)
point_min.z = min(point_min.z, centers["min"].z)
point_max.x = max(point_max.x, centers["max"].x)
point_max.y = max(point_max.y, centers["max"].y)
point_max.z = max(point_max.z, centers["max"].z)
else:
point_min, point_max = centers["min"], centers["max"]
if cam.lens.is_perspective():
vec = (point_min - point_max) * .5
center_pos = self.world.get_relative_point(tmp_np, point_max + vec)
else:
vec = point_max - point_min
center_pos = self.world.get_relative_point(tmp_np, point_min + vec * .5)
bounds_np.remove_node()
if cam.lens.is_perspective():
fov_h, fov_v = cam.lens.get_fov()
x, y, z = vec
x = min(-.01, x)
y = min(-.01, y)
z = min(-.01, z)
if vec.length_squared() < .000001:
zoom = None
else:
zoom = y + ((x / tan(radians(fov_h * .5))) if x / z > fov_h / fov_v
else (z / tan(radians(fov_v * .5))))
zoom = max(-1000000., min(-cam.lens.get_near(), zoom))
if transition:
if zoom is None:
interval1 = None
else:
interval1 = LerpPosInterval(cam.origin, .3, Point3(0., zoom, 0.),
blendType="easeInOut")
else:
set_zoom = lambda: None if zoom is None else cam.origin.set_y(zoom)
else:
size_h, size_v = cam.lens.get_film_size()
x, y, z = vec
x = max(.01, x)
y = max(.01, y)
z = max(.01, z)
if vec.length_squared() < .000001:
zoom = None
else:
zoom = (x / size_h) if x / z > size_h / size_v else (z / size_v)
zoom *= cam.target.get_sx()
zoom = min(100000., max(.0004, zoom))
if transition:
if zoom is None:
interval1 = None
else:
interval1 = LerpScaleInterval(cam.target, .3, zoom, blendType="easeInOut")
else:
set_zoom = lambda: None if zoom is None else cam.target.set_scale(zoom)
if transition:
interval2 = LerpPosInterval(cam.pivot, .3, center_pos, blendType="easeInOut")
lerp_interval = Parallel(interval2)
if interval1 is not None:
lerp_interval.append(interval1)
if obj_to_align_to:
quat = obj_to_align_to.get_pivot().get_quat(self.world)
interval3 = LerpQuatInterval(cam.pivot, .3, quat, blendType="easeInOut")
interval4 = LerpQuatInterval(cam.target, .3, Quat(), blendType="easeInOut")
interval5 = LerpQuatInterval(Mgr.get("view_gizmo_root"), .5,
quat, blendType="easeInOut")
lerp_interval.append(interval3)
lerp_interval.append(interval4)
lerp_interval.append(interval5)
self._lerp_interval = lerp_interval
lerp_interval.start()
Mgr.add_task(self.__transition_view, "transition_view", sort=30)
Mgr.do("start_view_gizmo_transition")
self._dest_view = "obj_extents"
self._transition_done = False
else:
cam.pivot.set_pos(center_pos)
set_zoom()
Mgr.do("update_transf_gizmo")
Mgr.do("update_coord_sys")
Mgr.do("update_zoom_indicator")
if obj_to_align_to:
Mgr.do("update_view_gizmo", False, True)
if GlobalData["coord_sys_type"] == "screen":
Mgr.get("selection").update_transform_values()
if obj_to_align_to:
self.is_front_custom = True
quat = Quat()
zoom = cam.zoom if zoom is None else zoom
self.custom_home_default_pos = center_pos
self.custom_home_default_quat = quat
self.custom_home_default_zoom = zoom
self.home_pos = center_pos
self.home_quat = quat
self.home_zoom = zoom
def setSwingInfo(self, power, angle, sequenceNum):
av = base.cr.doId2do.get(self.avId)
self.swingInterval = Sequence()
if av:
self.stopAdjustClubTask()
self.swingInterval = Sequence(ActorInterval(av, 'swing-putt', startFrame=0, endFrame=GolfGlobals.BALL_CONTACT_FRAME), Func(self.startBallPlayback, power, angle, sequenceNum), Func(self.ballModel.hide), ActorInterval(av, 'swing-putt', startFrame=GolfGlobals.BALL_CONTACT_FRAME, endFrame=24), Func(self.ballModel.setScale, 0.1), Func(self.ballModel.show), LerpScaleInterval(self.ballModel, 1.0, Point3(1, 1, 1)), Func(self.enableControlKey))
if av == localAvatar:
self.swingInterval.append(Func(self.switchToAnimState, 'GolfPuttLoop', True))
self.swingInterval.start()
class FountainPenAttack(Attack):
notify = directNotify.newCategory('FountainPenAttack')
attack = 'fountainpen'
def __init__(self, attacksClass, suit):
Attack.__init__(self, attacksClass, suit)
self.pen = None
self.spray = None
self.splat = None
self.spraySfx = None
self.sprayParticle = None
self.sprayScaleIval = None
self.wsnp = None
return
def loadAttack(self):
self.pen = loader.loadModel('phase_5/models/props/pen.bam')
self.pen.reparentTo(self.suit.find('**/joint_Rhold'))
self.sprayParticle = ParticleLoader.loadParticleEffect('phase_5/etc/penSpill.ptf')
self.spray = loader.loadModel('phase_3.5/models/props/spray.bam')
self.spray.setColor(VBase4(0, 0, 0, 1))
self.splat = Actor('phase_3.5/models/props/splat-mod.bam', {'chan': 'phase_3.5/models/props/splat-chan.bam'})
self.splat.setColor(VBase4(0, 0, 0, 1))
self.sprayScaleIval = LerpScaleInterval(self.spray, duration=0.3, scale=(1, 20, 1), startScale=(1, 1, 1))
sphere = CollisionSphere(0, 0, 0, 0.5)
sphere.setTangible(0)
if hasattr(self.suit, 'uniqueName'):
collName = self.suit.uniqueName('fountainPenCollNode')
else:
collName = 'fountainPenCollNode'
collNode = CollisionNode(collName)
collNode.addSolid(sphere)
collNode.setCollideMask(CIGlobals.WallBitmask)
self.wsnp = self.spray.attachNewNode(collNode)
self.wsnp.setY(1)
def doAttack(self, ts = 0):
self.loadAttack()
if hasattr(self.suit, 'uniqueName'):
name = self.suit.uniqueName('doFountainPenAttack')
else:
name = 'doFountainPenAttack'
self.suitTrack = Parallel(name=name)
self.suitTrack.append(ActorInterval(self.suit, 'fountainpen'))
self.suitTrack.append(Sequence(Wait(1.2), Func(self.acceptOnce, 'enter' + self.wsnp.node().getName(), self.handleSprayCollision), Func(self.playWeaponSound), Func(self.attachSpray), Func(self.sprayParticle.start, self.pen.find('**/joint_toSpray'), self.pen.find('**/joint_toSpray')), self.sprayScaleIval, Wait(0.5), Func(self.sprayParticle.cleanup), Func(self.spray.setScale, 1), Func(self.spray.reparentTo, hidden), Func(self.ignore, 'enter' + self.wsnp.node().getName())))
self.suitTrack.setDoneEvent(self.suitTrack.getName())
self.acceptOnce(self.suitTrack.getDoneEvent(), self.finishedAttack)
self.suitTrack.delayDelete = DelayDelete.DelayDelete(self.suit, name)
self.suitTrack.start(ts)
def attachSpray(self):
self.spray.reparentTo(self.pen.find('**/joint_toSpray'))
pos = self.spray.getPos(render)
hpr = self.spray.getHpr(render)
self.spray.reparentTo(render)
self.spray.setPos(pos)
self.spray.setHpr(hpr)
self.spray.setP(0)
if self.suit.type == 'C':
self.spray.setH(self.spray.getH() + 7.5)
self.spray.setTwoSided(True)
def handleSprayCollision(self, entry):
if self.suit:
self.suit.sendUpdate('toonHitByWeapon', [self.getAttackId(self.attack), base.localAvatar.doId])
base.localAvatar.b_handleSuitAttack(self.getAttackId(self.attack), self.suit.doId)
self.sprayScaleIval.pause()
def playWeaponSound(self):
self.spraySfx = base.audio3d.loadSfx('phase_5/audio/sfx/SA_fountain_pen.mp3')
base.audio3d.attachSoundToObject(self.spraySfx, self.pen)
self.spraySfx.play()
def cleanup(self):
Attack.cleanup(self)
if self.wsnp:
self.wsnp.node().clearSolids()
self.wsnp.removeNode()
self.wsnp = None
if self.pen:
self.pen.removeNode()
self.pen = None
if self.sprayParticle:
self.sprayParticle.cleanup()
self.sprayParticle = None
if self.spray:
self.spray.removeNode()
self.spray = None
if self.splat:
self.splat.cleanup()
self.splat = None
if self.sprayScaleIval:
self.sprayScaleIval.pause()
self.sprayScaleIval = None
self.spraySfx = None
return
def getDropIval(self, x, y, dropObjName, generation, num):
objType = PartyGlobals.Name2DropObjectType[dropObjName]
id = (generation, num)
dropNode = hidden.attachNewNode('catchDropNode%s' % (id, ))
dropNode.setPos(x, y, 0)
shadow = self.dropShadow.copyTo(dropNode)
shadow.setZ(PartyGlobals.CatchDropShadowHeight)
shadow.setColor(1, 1, 1, 1)
object = self.getObjModel(dropObjName)
object.reparentTo(hidden)
if dropObjName in ['watermelon', 'anvil']:
objH = object.getH()
absDelta = {'watermelon': 12, 'anvil': 15}[dropObjName]
delta = (self.randomNumGen.random() * 2.0 - 1.0) * absDelta
newH = objH + delta
else:
newH = self.randomNumGen.random() * 360.0
object.setH(newH)
sphereName = 'FallObj%s' % (id, )
radius = self.ObjRadius
if objType.good:
radius *= lerp(1.0, 1.3, 0.5)
collSphere = CollisionSphere(0, 0, 0, radius)
collSphere.setTangible(0)
collNode = CollisionNode(sphereName)
collNode.setCollideMask(PartyGlobals.CatchActivityBitmask)
collNode.addSolid(collSphere)
collNodePath = object.attachNewNode(collNode)
collNodePath.hide()
if self.ShowObjSpheres:
collNodePath.show()
catchEventName = 'ltCatch' + sphereName
def eatCollEntry(forward, collEntry):
forward()
self.accept(
catchEventName,
Functor(eatCollEntry, Functor(self.__handleCatch, id[0], id[1])))
def cleanup(self=self, dropNode=dropNode, id=id, event=catchEventName):
self.ignore(event)
dropNode.removeNode()
duration = objType.fallDuration
onscreenDuration = objType.onscreenDuration
targetShadowScale = 0.3
if self.trickShadows:
intermedScale = targetShadowScale * (self.OffscreenTime /
self.BaselineDropDuration)
shadowScaleIval = Sequence(
LerpScaleInterval(shadow,
self.OffscreenTime,
intermedScale,
startScale=0))
shadowScaleIval.append(
LerpScaleInterval(shadow,
duration - self.OffscreenTime,
targetShadowScale,
startScale=intermedScale))
else:
shadowScaleIval = LerpScaleInterval(shadow,
duration,
targetShadowScale,
startScale=0)
targetShadowAlpha = 0.4
shadowAlphaIval = LerpColorScaleInterval(
shadow,
self.OffscreenTime,
Point4(1, 1, 1, targetShadowAlpha),
startColorScale=Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
if self.useGravity:
def setObjPos(t, objType=objType, object=object):
z = objType.trajectory.calcZ(t)
object.setZ(z)
setObjPos(0)
dropIval = LerpFunctionInterval(setObjPos,
fromData=0,
toData=onscreenDuration,
duration=onscreenDuration)
else:
startPos = Point3(0, 0, self.MinOffscreenHeight)
object.setPos(startPos)
dropIval = LerpPosInterval(object,
onscreenDuration,
Point3(0, 0, 0),
startPos=startPos,
blendType='easeIn')
ival = Sequence(Func(Functor(dropNode.reparentTo, self.root)),
Parallel(
Sequence(
WaitInterval(self.OffscreenTime),
Func(Functor(object.reparentTo, dropNode)),
dropIval), shadowIval),
Func(cleanup),
name='drop%s' % (id, ))
if objType == PartyGlobals.Name2DropObjectType['anvil']:
ival.append(Func(self.playAnvil))
return ival
def enterAnnounceGameOver(self):
whistle = base.loadSfx('phase_4/audio/sfx/AA_sound_whistle.mp3')
base.playSfx(whistle)
self.gameOverLbl = OnscreenText(text='Game Over!', fg=(1, 1, 1, 1), font=CIGlobals.getMinnieFont(), scale=0.1)
self.gameOverScaleIval = LerpScaleInterval(self.gameOverLbl, duration=1.0, scale=0.1, startScale=0.0, blendType='easeOut')
def enterShowScores(self):
self.notify.debug('enterShowScores')
lerpTrack = Parallel()
lerpDur = 0.5
lerpTrack.append(Parallel(LerpPosInterval(self.goalBar, lerpDur, Point3(0, 0, -.6), blendType='easeInOut'), LerpScaleInterval(self.goalBar, lerpDur, Vec3(self.goalBar.getScale()) * 2.0, blendType='easeInOut')))
tY = 0.6
bY = -.05
lX = -.5
cX = 0
rX = 0.5
scorePanelLocs = (((cX, bY),),
((lX, bY), (rX, bY)),
((cX, tY), (lX, bY), (rX, bY)),
((lX, tY),
(rX, tY),
(lX, bY),
(rX, bY)))
scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
lerpTrack.append(Parallel(LerpPosInterval(panel, lerpDur, Point3(pos[0], 0, pos[1]), blendType='easeInOut'), LerpScaleInterval(panel, lerpDur, Vec3(panel.getScale()) * 2.0, blendType='easeInOut')))
self.showScoreTrack = Parallel(lerpTrack, Sequence(Wait(MazeGameGlobals.SHOWSCORES_DURATION), Func(self.gameOver)))
self.showScoreTrack.start()
class DistributedCameraShyGame(DistributedMinigame):
notify = directNotify.newCategory('DistributedCameraShyGame')
def __init__(self, cr):
try:
self.DistributedCameraShyGame_initialized
return
except:
self.DistributedCameraShyGame_initialized = 1
DistributedMinigame.__init__(self, cr)
self.headPanels.delete()
self.headPanels = CameraShyHeadPanels()
self.fsm.addState(State('countdown', self.enterCountdown, self.exitCountdown, ['play']))
self.fsm.addState(State('announceGameOver', self.enterAnnounceGameOver, self.exitAnnounceGameOver, ['showWinner']))
self.fsm.addState(State('showWinner', self.enterShowWinner, self.exitShowWinner, ['gameOver']))
self.fsm.getStateNamed('waitForOthers').addTransition('countdown')
self.fsm.getStateNamed('play').addTransition('announceGameOver')
self.maze = None
self.mazeCollModel = None
self.spawnPoints = []
self.remoteAvatars = []
self.myRemoteAvatar = None
self.thisPlayerWinsLbl = None
self.sky = None
self.firstPerson = CameraShyFirstPerson(self)
self.skyUtil = None
self.pbpText = None
return
def generateOtherPlayerGui(self):
self.headPanels.generateOtherPlayerGui()
def updateOtherPlayerHead(self, avId, otherAvId, state):
self.headPanels.updateOtherPlayerHead(avId, otherAvId, state)
def getPlayByPlayText(self):
return OnscreenText(text='', fg=(1, 1, 1, 1), shadow=(0, 0, 0, 1), pos=(0, 0.75))
def removePlayByPlay(self):
if self.pbpText:
taskMgr.remove('DCameraShyGame-removePlayByPlay')
self.pbpText.destroy()
self.pbpText = None
return
def removePlayByPlayTask(self, task):
self.removePlayByPlay()
return Task.done
def showPlayByPlay(self, situation, avId):
self.removePlayByPlay()
av = self.cr.doId2do.get(avId)
name = av.getName()
if situation == 0:
self.pbpText = self.getPlayByPlayText()
self.pbpText.setText('{0} took a picture of you!'.format(name))
taskMgr.doMethodLater(3.0, self.removePlayByPlayTask, 'DCameraShyGame-removePlayByPlay')
def tookPictureOfMe(self, avId):
self.headPanels.hideFrames()
self.firstPerson.stopCameraFlash()
base.transitions.setFadeColor(1, 1, 1)
base.transitions.fadeOut(0.1)
self.showPlayByPlay(0, avId)
Sequence(Wait(1), Func(self.respawn)).start()
def respawn(self):
base.transitions.fadeIn()
pos, hpr = self.pickSpawnPoint()
base.localAvatar.setPos(pos)
base.localAvatar.setHpr(hpr - (180, 0, 0))
base.localAvatar.d_broadcastPositionNow()
Sequence(Wait(0.6), Func(self.headPanels.showFrames), Func(base.transitions.setFadeColor, 0, 0, 0)).start()
def announceGameOver(self):
self.fsm.request('announceGameOver')
def showWinner(self, avId):
base.transitions.fadeOut()
Sequence(Wait(0.51), Func(self.fsm.request, 'showWinner', [avId])).start()
def enterGameOver(self, winner, winnerDoId, allPrize):
try:
currentCamPos = base.camera.getPos(render)
currentCamHpr = base.camera.getHpr(render)
self.firstPerson.reallyEnd()
base.camera.setPos(currentCamPos)
base.camera.setHpr(currentCamHpr)
except:
pass
DistributedMinigame.enterGameOver(self, winner, winnerDoId, allPrize)
def enterShowWinner(self, winnerId):
self.firstPerson.reallyEnd()
avatar = self.getRemoteAvatar(winnerId)
avatar.avatar.loop('neutral')
avatar.detachCamera()
self.thisPlayerWinsLbl = OnscreenText(text='{0} Wins!'.format(avatar.avatar.getName()), fg=(1, 1, 1, 1), font=CIGlobals.getMinnieFont(), pos=(0, 0.8), scale=0.1)
if winnerId == base.localAvatar.doId:
self.thisPlayerWinsLbl.setText('You Win!')
base.camera.reparentTo(avatar.avatar)
base.camera.setPos(0, 7, 3)
base.camera.setH(180)
base.transitions.fadeIn()
Sequence(Wait(0.5), Func(avatar.doWinDance)).start()
def exitShowWinner(self):
pass
def enterAnnounceGameOver(self):
whistle = base.loadSfx('phase_4/audio/sfx/AA_sound_whistle.mp3')
base.playSfx(whistle)
self.gameOverLbl = OnscreenText(text='Game Over!', fg=(1, 1, 1, 1), font=CIGlobals.getMinnieFont(), scale=0.1)
self.gameOverScaleIval = LerpScaleInterval(self.gameOverLbl, duration=1.0, scale=0.1, startScale=0.0, blendType='easeOut')
def exitAnnounceGameOver(self):
self.gameOverScaleIval.finish()
del self.gameOverScaleIval
self.gameOverLbl.destroy()
del self.gameOverLbl
def remoteAvatarTakePicture(self, avId):
avatar = self.getRemoteAvatar(avId)
if avatar:
avatar.takePicture()
def standingAvatar(self, avId):
avatar = self.getRemoteAvatar(avId)
if avatar:
avatar.stand()
def runningAvatar(self, avId):
avatar = self.getRemoteAvatar(avId)
if avatar:
avatar.run()
def createRemoteAvatar(self, avId):
if avId == base.localAvatar.doId:
self.myRemoteAvatar = RemoteCameraShyAvatar(self, self.cr, avId)
self.remoteAvatars.append(self.myRemoteAvatar)
else:
av = RemoteCameraShyAvatar(self, self.cr, avId)
av.stand()
self.remoteAvatars.append(av)
def getRemoteAvatar(self, avId):
for avatar in self.remoteAvatars:
if avatar.avId == avId:
return avatar
def allPlayersReady(self):
self.fsm.request('countdown')
def enterCountdown(self):
base.localAvatar.chatInput.disableKeyboardShortcuts()
base.localAvatar.disableChatInput()
base.setBackgroundColor(CIGlobals.DefaultBackgroundColor)
base.render.show()
self.playMinigameMusic()
self.countdownLbl = OnscreenText(text='', fg=(1, 1, 1, 1), font=CIGlobals.getMinnieFont(), scale=0.1)
self.countdownTrack = Sequence(Func(self.countdownLbl.setText, '5'), Wait(1.0), Func(self.countdownLbl.setText, '4'), Wait(1.0), Func(self.countdownLbl.setText, '3'), Wait(1.0), Func(self.countdownLbl.setText, '2'), Wait(1.0), Func(self.countdownLbl.setText, '1'), Wait(1.0), Func(self.fsm.request, 'play'))
self.countdownTrack.start()
self.firstPerson.start()
self.firstPerson.disableMouse()
def exitCountdown(self):
if hasattr(self, 'countdownTrack'):
self.countdownTrack.pause()
del self.countdownTrack
if hasattr(self, 'countdownLbl'):
self.countdownLbl.destroy()
del self.countdownLbl
def enterPlay(self):
self.createTimer()
self.firstPerson.reallyStart()
def exitPlay(self):
self.firstPerson.end()
self.firstPerson.enableMouse()
self.deleteTimer()
base.localAvatar.createChatInput()
base.localAvatar.chatInput.enableKeyboardShortcuts()
DistributedMinigame.exitPlay(self)
def createWorld(self):
self.deleteWorld()
self.maze = loader.loadModel('phase_4/models/minigames/maze_1player.bam')
self.maze.find('**/maze_walls').setSz(1.5)
self.maze.reparentTo(base.render)
self.mazeCollModel = loader.loadModel('phase_4/models/minigames/maze_1player_collisions.egg')
self.mazeCollModel.reparentTo(base.render)
self.mazeCollModel.hide()
self.mazeCollModel.setTransparency(1)
self.mazeCollModel.setColorScale(1, 1, 1, 0)
for node in self.mazeCollModel.findAllMatches('**'):
node.setSz(1.5)
self.sky = loader.loadModel('phase_3.5/models/props/TT_sky.bam')
self.skyUtil = SkyUtil()
self.skyUtil.startSky(self.sky)
self.sky.reparentTo(base.camera)
ce = CompassEffect.make(NodePath(), CompassEffect.PRot | CompassEffect.PZ)
self.sky.node().setEffect(ce)
self.spawnPoints.append((Point3(0, 0, 0), Vec3(0, 0, 0)))
self.spawnPoints.append((Point3(-23.89, 18.58, 0.0), Vec3(90.0, 0.0, 0.0)))
self.spawnPoints.append((Point3(-23.89, 6.3, 0.0), Vec3(0.0, 0.0, 0.0)))
self.spawnPoints.append((Point3(23.78, 6.3, 0.0), Vec3(0.0, 0.0, 0.0)))
self.spawnPoints.append((Point3(8.12, -17.79, 0.0), Vec3(270.0, 0.0, 0.0)))
def deleteWorld(self):
if self.maze:
self.maze.removeNode()
self.maze = None
if self.mazeCollModel:
self.mazeCollModel.removeNode()
self.mazeCollModel = None
if self.skyUtil:
self.skyUtil.stopSky()
self.skyUtil = None
if self.sky:
self.sky.removeNode()
self.sky = None
return
def pickSpawnPoint(self):
return random.choice(self.spawnPoints)
def setSpawnPoint(self, index):
pos, hpr = self.spawnPoints[index]
base.localAvatar.setPos(pos)
base.localAvatar.setHpr(hpr)
def load(self):
self.createWorld()
self.setMinigameMusic('phase_6/audio/bgm/GS_Race_SS.mid')
self.setDescription('Be the first to take 3 pictures of all the other Toons with your camera. ' + 'Use WASD to move and the mouse to look around. Press the left mouse button to take a picture. ' + 'Your camera takes some time to recharge after taking a picture. ' + 'You know you have a good shot when the view finder is green!')
self.setWinnerPrize(30)
self.setLoserPrize(15)
base.render.hide()
base.setBackgroundColor(0, 0, 0)
DistributedMinigame.load(self)
def announceGenerate(self):
base.camLens.setMinFov(CIGlobals.GunGameFOV / (4.0 / 3.0))
self.load()
DistributedMinigame.announceGenerate(self)
def disable(self):
if self.thisPlayerWinsLbl:
self.thisPlayerWinsLbl.destroy()
self.thisPlayerWinsLbl = None
base.camera.reparentTo(render)
base.camera.setPos(0, 0, 0)
base.camera.setHpr(0, 0, 0)
if self.myRemoteAvatar:
self.myRemoteAvatar.cleanup()
del self.myRemoteAvatar
self.firstPerson.cleanup()
del self.firstPerson
self.deleteWorld()
base.camLens.setMinFov(CIGlobals.DefaultCameraFov / (4.0 / 3.0))
DistributedMinigame.disable(self)
return
class Highlightable:
"""A mixin class that receives notifications from zcanvas when the mouse
pointer enters or leaves its nodepath. These events can be used to highlight
a nodepath as the mouse cursor moves over it. The default implementation
scales the nodepath to 120% of its original size over a 0.2 second interval
when the mouse enters the nodepath, and scales it back over the same amount
of time when the mouse leaves."""
def __init__(self):
pass
def highlight(self):
"""The mouse pointer has entered the bounds of this nodepath. Subclasses
should override this method to implement custom mouse-over behaviour.
"""
# If we are already scaling up, do nothing.
if hasattr(self,'scaleUpInterval') and self.scaleUpInterval.isPlaying():
return
# If we are in the process of scaling down, finish it off immediately.
if hasattr(self,'scaleDownInterval') and self.scaleDownInterval.isPlaying():
self.scaleDownInterval.finish()
from direct.interval.IntervalGlobal import LerpScaleInterval
self.prevScale = self.getScale()
self.scaleUpInterval = LerpScaleInterval(self.np, duration=0.2, scale=self.getScale()*1.2, startScale=self.getScale())
self.scaleUpInterval.start()
def unhighlight(self):
"""The mouse pointer has left the bounds of this nodepath. Subclasses
should override this method to implement custom mouse-over behaviour.
"""
# If we are already scaling down, do nothing.
if hasattr(self,'scaleDownInterval') and self.scaleDownInterval.isPlaying():
return
# If we are in the process of scaling up, stop.
if hasattr(self,'scaleUpInterval') and self.scaleUpInterval.isPlaying():
self.scaleUpInterval.pause()
from direct.interval.IntervalGlobal import LerpScaleInterval
self.scaleDownInterval = LerpScaleInterval(self.np, duration=0.2, scale=self.prevScale, startScale=self.getScale())
self.scaleDownInterval.start()
def set_highlightable(self,boolean):
"""Enable or disable mouse-over highlighting of this nodepath. (When
disabled, the highlight and unhighlight methods will not be
called.)
"""
# Finish any intervals that are playing.
if hasattr(self,'scaleDownInterval') and self.scaleDownInterval.isPlaying():
self.scaleDownInterval.finish()
elif hasattr(self,'scaleUpInterval') and self.scaleUpInterval.isPlaying():
self.scaleUpInterval.finish()
# Reset the scale.
if hasattr(self,'prevScale'):
self.setScale(self.prevScale)
if boolean:
self.np.setPythonTag("highlightable",self)
else:
self.np.clearPythonTag("highlightable")
def onActivate(self, entity, suit):
slidePos = entity.getPos(render)
slidePos.setY(slidePos.getY() - 5.1)
moveTrack = Sequence(Wait(0.1), LerpPosInterval(self.gag, 0.1, slidePos))
animTrack = Sequence(ActorInterval(self.gag, 'banana', startTime=3.1), Wait(1.1), LerpScaleInterval(self.gag, 1,
Point3(0.01, 0.01, 0.01)))
suitTrack = ActorInterval(suit, 'slip-backward')
soundTrack = Sequence(SoundInterval(self.slipSfx, duration=0.55, node=suit), SoundInterval(self.activateSfx, node=suit))
Parallel(moveTrack, animTrack, suitTrack, soundTrack).start()
ActivateTrapGag.onActivate(self, entity, suit)