def enterFinalResults(self):
lerpTrack = Parallel()
lerpDur = 0.5
tY = 0.6
bY = -0.05
lX = -0.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 aux_quitmenu(self):
self.nomove = False
self.app.change_cursor(0)
self.lst_gui["frames"][self.lst_menus[1] + 1].hide()
self.arc_aux_menu.play("unload")
self.app.accept("escape", sys.exit, [0])
self.app.ignore("backspace")
self.app.ignore("enter")
self.app.ignore("arrow_up")
self.app.ignore("arrow_down")
if self.lst_menus[1] == 0: #campaign
self.app.ignore("delete")
self.app.lst_arrows[2]["status"] = 0
self.app.lst_arrows[3]["status"] = 0
self.app.lst_arrows[2]["node"].hide()
self.app.lst_arrows[3]["node"].hide()
elif self.lst_menus[1] == 1: #missions
#
#TODO : arrows pour le sous menu "missions"
#
#
pass
#
movePara = Parallel(name="aux_to_main")
movePara.append(camera.posInterval(2, Point3(0, -25, 12)))
movePara.append(camera.hprInterval(2, Point3(0, -10, 0)))
movePara.start()
taskMgr.doMethodLater(2.5, self.main_affmm_task,
"main aff main menu task")
self.lst_menus[0] = 0
def enterFinalResults(self):
lerpTrack = Parallel()
lerpDur = 0.5
tY = 0.59999999999999998
bY = -0.050000000000000003
lX = -0.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(IceGameGlobals.ShowScoresDuration),
Func(self.gameOver)))
self.showScoreTrack.start()
def main_m_menu_state_change(self, sens):
if sens == 2: #capture depuis le click souris
if self.app.lst_arrows[0]["status"] == 2: sens = 0
elif self.app.lst_arrows[1]["status"] == 2: sens = 1
else: return
if sens == 0 and self.lst_menus[1] == 3: return
elif sens == 1 and self.lst_menus[1] == 0: return
pos_texts = [(-0.35, 0, 0.23), (-0.26, 0, 0.1), (-0.19, 0, -0.04),
(-0.15, 0, -0.2), (-0.19, 0, -0.34), (-0.26, 0, -0.47),
(-0.35, 0, -0.58)]
scale_texts = [0.07, 0.09, 0.1, 0.12, 0.1, 0.09, 0.07]
self.lst_gui["main_frame"][self.lst_menus[1]]["state"] = DGG.DISABLED
if sens == 0:
if self.lst_menus[1] == 0: self.app.lst_arrows[1]["node"].show()
if self.lst_menus[1] == 2: self.app.lst_arrows[0]["node"].hide()
self.arc_main_menu.play("state_" + str(self.lst_menus[1]) + "_" +
str(self.lst_menus[1] + 1))
self.lst_menus[1] += 1
elif sens == 1:
if self.lst_menus[1] == 1: self.app.lst_arrows[1]["node"].hide()
if self.lst_menus[1] == 3: self.app.lst_arrows[0]["node"].show()
self.arc_main_menu.play("state_" + str(self.lst_menus[1]) + "_" +
str(self.lst_menus[1] - 1))
self.lst_menus[1] -= 1
movePara = Parallel(name="texts_move")
for it in range(4):
movePara.append(self.lst_gui["main_frame"][it].posInterval(
0.5, Point3(pos_texts[3 - self.lst_menus[1] + it])))
movePara.append(self.lst_gui["main_frame"][it].scaleInterval(
0.5, scale_texts[3 - self.lst_menus[1] + it]))
movePara.start()
self.lst_gui["main_frame"][self.lst_menus[1]]["state"] = DGG.NORMAL
def getSwapVisibleIval(self, wait = 5.0, tFadeOut = 3.0, tFadeIn = 3.0):
loader = base.cr.playGame.hood.loader
npl = render.findAllMatches('**/=DNARoot=holiday_prop;+s')
p = Parallel()
for i in range(npl.getNumPaths()):
np = npl.getPath(i)
np.setTransparency(TransparencyAttrib.MDual, 1)
if not np.hasTag('DNACode'):
continue
dnaCode = np.getTag('DNACode')
dnaNode = self.dnaStore.findNode(dnaCode)
if dnaNode.isEmpty():
continue
newNP = dnaNode.copyTo(np.getParent())
newNP.setTag('DNARoot', 'holiday_prop')
newNP.setTag('DNACode', dnaCode)
newNP.setColorScale(1, 1, 1, 0)
newNP.setTransparency(TransparencyAttrib.MDual, 1)
if np.hasTag('transformIndex'):
index = int(np.getTag('transformIndex'))
transform = loader.holidayPropTransforms.get(index, TransformState.makeIdentity())
newNP.setTransform(NodePath(), transform)
newNP.setTag('transformIndex', `index`)
s = Sequence(Wait(wait), np.colorScaleInterval(tFadeOut, Vec4(1, 1, 1, 0), startColorScale=Vec4(1, 1, 1, 1), blendType='easeInOut'), Func(np.detachNode), Func(np.clearTransparency), newNP.colorScaleInterval(tFadeOut, Vec4(1, 1, 1, 1), startColorScale=Vec4(1, 1, 1, 0), blendType='easeInOut'), Func(newNP.clearTransparency), Func(newNP.clearColorScale))
p.append(s)
return p
def getBobSequence(self, animName, startFrame, endFrame, playRate):
def __animTrack_bobUp(partName):
return ActorInterval(self.avatar,
animName,
startFrame=startFrame,
endFrame=endFrame,
partName=partName,
playRate=playRate)
def __animTrack_bobDown(partName):
return ActorInterval(self.avatar,
animName,
startFrame=endFrame,
endFrame=startFrame,
partName=partName,
playRate=playRate)
uppers = self.avatar.getUpperBodySubpart()
seq = Sequence()
bobUp = Parallel()
for part in uppers:
bobUp.append(__animTrack_bobUp(part))
bobDown = Parallel()
for part in uppers:
bobDown.append(__animTrack_bobDown(part))
seq.append(bobUp)
seq.append(bobDown)
return seq
def getSwapVisibleIval(self, wait = 5.0, tFadeOut = 3.0, tFadeIn = 3.0):
loader = base.cr.playGame.hood.loader
npl = render.findAllMatches('**/=DNARoot=holiday_prop;+s')
p = Parallel()
for i in range(npl.getNumPaths()):
np = npl.getPath(i)
np.setTransparency(TransparencyAttrib.MDual, 1)
if not np.hasTag('DNACode'):
continue
dnaCode = np.getTag('DNACode')
dnaNode = self.dnaStore.findNode(dnaCode)
if dnaNode.isEmpty():
continue
newNP = dnaNode.copyTo(np.getParent())
newNP.setTag('DNARoot', 'holiday_prop')
newNP.setTag('DNACode', dnaCode)
newNP.setColorScale(1, 1, 1, 0)
newNP.setTransparency(TransparencyAttrib.MDual, 1)
if np.hasTag('transformIndex'):
index = int(np.getTag('transformIndex'))
transform = loader.holidayPropTransforms.get(index, TransformState.makeIdentity())
newNP.setTransform(NodePath(), transform)
newNP.setTag('transformIndex', `index`)
s = Sequence(Wait(wait), np.colorScaleInterval(tFadeOut, Vec4(1, 1, 1, 0), startColorScale=Vec4(1, 1, 1, 1), blendType='easeInOut'), Func(np.detachNode), Func(np.clearTransparency), newNP.colorScaleInterval(tFadeOut, Vec4(1, 1, 1, 1), startColorScale=Vec4(1, 1, 1, 0), blendType='easeInOut'), Func(newNP.clearTransparency), Func(newNP.clearColorScale))
p.append(s)
return p
def __getMakePileTrack(self, mound, shadow, avatar):
scaleIncr = float(MOUND_MAX_SCALE / DIG_DURATION)
posIncr = float(1.0 / DIG_DURATION)
track = Sequence(ShowInterval(mound))
scale = MOUND_INITIAL_SCALE
pos = (0.0, 0.0, -0.25)
for i in range(int(DIG_DURATION)):
newScale = (scale + scaleIncr) if (
scale + scaleIncr) < MOUND_MAX_SCALE else MOUND_MAX_SCALE
newPos = (0.0, 0.0, pos[2] +
posIncr) if (pos[2] + posIncr) < 1.0 else (0.0, 0.0, 1.0)
parallelIval = Parallel()
if (i % 2 == 0) or (i == int(DIG_DURATION) - 1):
parallelIval.append(
SoundInterval(self.digSfx, node=avatar, duration=0.55))
parallelIval.append(
self.__getEnlargePileInterval(mound, scale, newScale, pos,
newPos, 1.0))
track.append(parallelIval)
scale = newScale
pos = newPos
return Parallel(
track,
Sequence(
Wait(1.0), ShowInterval(shadow),
LerpScaleInterval(shadow,
DIG_DURATION + 1.0,
MOUND_MAX_SCALE - 1.25,
startScale=MOUND_INITIAL_SCALE,
blendType='easeInOut')))
def getVictoryRunTrack(self):
origPosTrack = Sequence()
delayDeletes = []
i = 0
for victor in self.victorList:
if victor != 0 and victor in self.cr.doId2do:
toon = self.cr.doId2do[victor]
delayDeletes.append(
DelayDelete.DelayDelete(toon, 'getVictoryRunTrack'))
toon.stopSmooth()
toon.setParent(CIGlobals.SPHidden)
origPosTrack.append(
Func(toon.setPosHpr, self.elevatorNodePath,
apply(Point3, ElevatorPoints[i]), Point3(180, 0, 0)))
origPosTrack.append(Func(toon.setParent, CIGlobals.SPRender))
i += 1
openDoors = getOpenInterval(self, self.leftDoor, self.rightDoor,
self.openSfx, None)
toonDoorPosHpr = self.cr.playGame.dnaStore.getDoorPosHprFromBlockNumber(
self.block)
useFarExitPoints = toonDoorPosHpr.getPos(render).getZ() > 1.0
runOutAll = Parallel()
i = 0
for victor in self.victorList:
if victor != 0 and victor in self.cr.doId2do:
toon = self.cr.doId2do[victor]
p0 = Point3(0, 0, 0)
p1 = Point3(ElevatorPoints[i][0], ElevatorPoints[i][1] - 5.0,
ElevatorPoints[i][2])
if useFarExitPoints:
p2 = Point3(ElevatorOutPointsFar[i][0],
ElevatorOutPointsFar[i][1],
ElevatorOutPointsFar[i][2])
else:
p2 = Point3(ElevatorOutPoints[i][0],
ElevatorOutPoints[i][1],
ElevatorOutPoints[i][2])
runOutSingle = Sequence(
Func(toon.animFSM.request, 'run'),
LerpPosInterval(toon,
TOON_VICTORY_EXIT_TIME * 0.25,
p1,
other=self.elevatorNodePath),
Func(toon.headsUp, self.elevatorNodePath, p2),
LerpPosInterval(toon,
TOON_VICTORY_EXIT_TIME * 0.5,
p2,
other=self.elevatorNodePath),
LerpHprInterval(toon,
TOON_VICTORY_EXIT_TIME * 0.25,
Point3(0, 0, 0),
other=self.elevatorNodePath),
Func(toon.animFSM.request, 'neutral'),
Func(toon.startSmooth))
runOutAll.append(runOutSingle)
i += 1
victoryRunTrack = Sequence(origPosTrack, openDoors, runOutAll)
return (victoryRunTrack, delayDeletes)
class SequencePlayer():
def __init__(self):
self.wait = base.turn_speed
self.parallel = None
def end(self):
self.wait = base.turn_speed
self.parallel = None
def hold(self, time):
self.wait = time
self.add_to_sequence()
def add_to_sequence(self, *kwargs):
if not self.parallel:
self.parallel = Parallel()
for item in kwargs:
self.parallel.append(item)
def finalize(self):
if not self.parallel:
self.parallel = Parallel()
func = Sequence(Wait(self.wait), Func(self.end))
self.parallel.append(func)
self.parallel.start()
def doSpray(self, scaleUp, scaleDown, hold):
base.audio3d.attachSoundToObject(self.spraySfx, self.gag)
self.spraySfx.play()
spraySequence = Sequence(Func(self.getSprayTrack(self.origin, self.sprayRange, scaleUp, hold, scaleDown).start))
sprayParallel = Parallel()
sprayParallel.append(Func(spraySequence.start))
sprayParallel.start()
def getAnimationTrack(self,
animName,
startFrame=None,
endFrame=None,
playRate=1.0,
startTime=None,
endTime=None,
fullBody=False):
seq = Parallel()
def __animTrack(partName):
return ActorInterval(self.avatar,
animName,
startFrame=startFrame,
endFrame=endFrame,
partName=partName,
playRate=playRate,
startTime=startTime,
endTime=endTime)
if not fullBody:
uppers = self.avatar.getUpperBodySubpart()
for part in uppers:
seq.append(__animTrack(part))
else:
seq.append(__animTrack(None))
return seq
def getScaleBlendIntervals(self, props, duration, startScale, endScale, blendType):
tracks = Parallel()
if not isinstance(props, list):
props = [props]
for prop in props:
tracks.append(LerpScaleInterval(prop, duration, endScale, startScale=startScale, blendType=blendType))
return tracks
def getScaleTrack(self, props, duration, startScale, endScale):
track = Parallel()
if not isinstance(props, list):
props = [props]
for prop in props:
track.append(LerpScaleInterval(prop, duration, endScale, startScale=startScale))
return track
def showPath(self, fr, to): path = set() showSquareSequences = Parallel() if self.pieces[fr]: path.update(self.pieces[fr].path(to)) for sq in path: showSquareSequences.append(self.showSquare(sq)) return showSquareSequences
def createOnePlayerSequence(self, index, duration):
"""
create a sequence for one player
"""
numVotes = self.votes[index]
direction = self.directions[index]
def ticketTicker(t, label = self.entryList[index][direction+1],
startVotes = 0, endVotes = numVotes):
label['text'] = str( int(t*endVotes + startVotes))
track = Parallel()
#track.append(Func(self.entryList[index][0].show, name='showName %d' % index))
#track.append(LerpFunc(ticketTicker,duration=duration, name='countVotes %d'% index))
# lets figure out the total before
startVotes = 0
for prev in range(index):
if self.directions[prev] == direction:
startVotes += self.votes[prev]
def totalTicker(t, label = self.totalVotesLabels[direction],
startVotes = startVotes, additionalVotes = numVotes):
label['text'] = str( int(t*additionalVotes + startVotes))
track.append(LerpFunc(totalTicker, duration=duration, name='countTotal %d' %index))
if index in self.avVotesLabel:
def avVotesTicker(t, label = self.avVotesLabel[index],
startVotes = 0, endVotes = numVotes, direction = direction):
oldValue = label['text']
newValue = int(t*endVotes + startVotes)
label['text'] = str(newValue)
if not oldValue == label['text']:
if newValue:
if direction == 0:
self.upArrowSfx[self.curArrowSfxIndex].play()
else:
self.downArrowSfx[self.curArrowSfxIndex].play()
self.curArrowSfxIndex += 1
if self.curArrowSfxIndex >= len(self.upArrowSfx):
self.curArrowSfxIndex = 0
label = self.avVotesLabel[index]
track.append(Func(self.avVotesLabel[index].show, name='showName %d' % index))
if index in self.avArrows:
track.append(Func(self.avArrows[index].show, name='showArrow %d' % index))
if direction == 0 and numVotes:
#track.append(SoundInterval(self.upArrowSfx))
pass
elif direction == 1 and numVotes:
#track.append(SoundInterval(self.downArrowSfx))
pass
else:
track.append(SoundInterval(self.noVoteSfx))
track.append(LerpFunc(avVotesTicker,duration=duration,
name='countAvVotes %d'% index))
return track
def hide(self):
if self.__hidden:
return
self.__hidden = True
if not (self.__fading and self.__fadingDuration):
NodePath.hide(self)
self.removeFocus()
if self.__mask:
self.__mask.hide()
if self.__bgPath:
self.__bgPath.hide()
if self.__hiddenFunc:
self.__hiddenFunc(*self.__eventExtraArgs)
else:
#self.removeFocus()
if self.__currentInterval:
self.__currentInterval.pause()
endpos = tuple(
map(operator.add, self.__originPos,
self.__fadingPositionOffset))
parallel = Parallel(
LerpFunc(_modifyAlphaScale,
self.__fadingDuration,
1,
0,
blendType='easeIn',
extraArgs=[self]),
LerpPosInterval(self,
self.__fadingDuration,
endpos,
self.__originPos,
blendType='easeIn'),
)
if self.__bgPath:
parallel.append(
LerpFunc(_modifyAlphaScale,
self.__fadingDuration,
1,
0,
blendType='easeIn',
extraArgs=[self.__bgPath]))
self.__currentInterval = Sequence(
parallel,
Func(NodePath.hide, self),
Func(self.removeFocus),
)
if self.__mask:
self.__currentInterval.append(Func(self.__mask.hide))
if self.__bgPath:
self.__currentInterval.append(Func(self.__bgPath.hide))
if self.__hiddenFunc:
self.__currentInterval.append(
Func(self.__hiddenFunc, *self.__eventExtraArgs))
self.__currentInterval.start()
def doGagEffect(suit, flags):
if not CIGlobals.isNodePathOk(suit):
return
effect = Parallel()
for id in Effects.keys():
if (flags & id) != 0:
print("Doing effect", id)
effect.append(Effects[id](suit))
effect.start()
def getScaleIntervals(self, props, duration, startScale, endScale):
tracks = Parallel()
if not isinstance(props, list):
props = [props]
for prop in props:
tracks.append(
LerpScaleInterval(prop,
duration,
endScale,
startScale=startScale))
return tracks
def show(self):
if not self.__hidden:
return
self.__hidden = False
if self.__mask or self.__bgPath:
if self.__mask:
self.__mask.reparentTo(aspect2d, sort=self.getSort())
self.__mask.show()
if self.__bgPath:
self.__bgPath.reparentTo(aspect2d, sort=self.getSort())
self.__bgPath.show()
self.reparentTo(self.getParent(), sort=self.getSort())
if not (self.__fading and self.__fadingDuration):
NodePath.show(self)
self.requestFocus()
if self.__shownFunc:
self.__shownFunc(*self.__eventExtraArgs)
else:
NodePath.show(self)
self.requestFocus()
if self.__currentInterval:
self.__currentInterval.pause()
pos = tuple(
map(operator.add, self.__originPos,
self.__fadingPositionOffset))
parallel = Parallel(
LerpFunc(_modifyAlphaScale,
self.__fadingDuration,
0,
1,
blendType='easeOut',
extraArgs=[self]),
LerpPosInterval(self,
self.__fadingDuration,
self.__originPos,
pos,
blendType='easeOut'))
if self.__bgPath:
parallel.append(
LerpFunc(_modifyAlphaScale,
self.__fadingDuration,
0,
1,
blendType='easeOut',
extraArgs=[self.__bgPath]))
self.__currentInterval = Sequence(parallel)
if self.__shownFunc:
self.__currentInterval.append(
Func(self.__shownFunc, *self.__eventExtraArgs))
self.__currentInterval.start()
def __tickNearbyCogs(self):
self.__selectNearbyCogs()
tickTrack = Parallel()
tickDuration = 0.4
for cog in self.selectedCogs:
if not cog.isDead():
base.audio3d.attachSoundToObject(self.tickSfx, cog)
tickTrack.append(Parallel(Sequence(LerpColorScaleInterval(cog, tickDuration, VBase4(1, 0, 0, 1)), Func(cog.clearColorScale), Func(cog.d_disableMovement)), SoundInterval(self.tickSfx, duration=tickDuration, node=cog)))
else:
self.selectedCogs.remove(cog)
return tickTrack
def showPathIfVisible(self, fr, to): if self.pieces[fr]: path = set() showSquareSequences = Parallel() if self.pieces[fr]: path.update(self.pieces[fr].path(to)) if any(self.isVisible(sq) for sq in path): for sq in path: showSquareSequences.append(self.showSquare(sq)) return showSquareSequences else: return Parallel()
def createOnePlayerSequence(self, index, duration):
numVotes = self.votes[index]
direction = self.directions[index]
def ticketTicker(t, label = self.entryList[index][direction + 1], startVotes = 0, endVotes = numVotes):
label['text'] = str(int(t * endVotes + startVotes))
track = Parallel()
startVotes = 0
for prev in range(index):
if self.directions[prev] == direction:
startVotes += self.votes[prev]
continue
def totalTicker(t, label = self.totalVotesLabels[direction], startVotes = startVotes, additionalVotes = numVotes):
label['text'] = str(int(t * additionalVotes + startVotes))
track.append(LerpFunc(totalTicker, duration = duration, name = 'countTotal %d' % index))
if self.avVotesLabel.has_key(index):
def avVotesTicker(t, label = self.avVotesLabel[index], startVotes = 0, endVotes = numVotes, direction = direction):
oldValue = label['text']
newValue = int(t * endVotes + startVotes)
label['text'] = str(newValue)
if not oldValue == label['text']:
if newValue:
if direction == 0:
self.upArrowSfx[self.curArrowSfxIndex].play()
else:
self.downArrowSfx[self.curArrowSfxIndex].play()
self.curArrowSfxIndex += 1
if self.curArrowSfxIndex >= len(self.upArrowSfx):
self.curArrowSfxIndex = 0
label = self.avVotesLabel[index]
track.append(Func(self.avVotesLabel[index].show, name = 'showName %d' % index))
if self.avArrows.has_key(index):
track.append(Func(self.avArrows[index].show, name = 'showArrow %d' % index))
if direction == 0 and numVotes:
pass
1
if direction == 1 and numVotes:
pass
1
track.append(SoundInterval(self.noVoteSfx))
track.append(LerpFunc(avVotesTicker, duration = duration, name = 'countAvVotes %d' % index))
return track
def __tickNearbyCogs(self):
self.__selectNearbyCogs()
tickTrack = Parallel()
tickDuration = 0.4
for cog in self.selectedCogs:
if not cog.isDead():
base.audio3d.attachSoundToObject(self.tickSfx, cog)
tickTrack.append(Parallel(Sequence(LerpColorScaleInterval(cog, tickDuration, VBase4(1, 0, 0, 1)), Func(cog.clearColorScale), Func(cog.d_disableMovement)), SoundInterval(self.tickSfx, duration=tickDuration)))
else:
self.selectedCogs.remove(cog)
return tickTrack
def animToSuit(self, timeStamp):
self.stopTransition()
if self.mode != 'toon':
self.setToToon()
self.loadAnimToSuitSfx()
sideBldgNodes = self.getNodePaths()
nodePath = hidden.find(self.getSbSearchString())
newNP = self.setupSuitBuilding(nodePath)
if not self.leftDoor:
return
closeDoors(self.leftDoor, self.rightDoor)
newNP.stash()
sideBldgNodes.append(newNP)
soundPlayed = 0
tracks = Parallel(name=self.taskName('toSuitTrack'))
for i in sideBldgNodes:
name = i.getName()
timeForDrop = TO_SUIT_BLDG_TIME * 0.85
if name[0] == 's':
showTrack = Sequence(name=self.taskName('ToSuitFlatsTrack') + '-' + str(sideBldgNodes.index(i)))
initPos = Point3(0, 0, self.SUIT_INIT_HEIGHT) + i.getPos()
showTrack.append(Func(i.setPos, initPos))
showTrack.append(Func(i.unstash))
if i == sideBldgNodes[len(sideBldgNodes) - 1]:
showTrack.append(Func(self.normalizeElevator))
if not soundPlayed:
showTrack.append(Func(base.playSfx, self.cogDropSound, 0, 1, None, 0.0))
showTrack.append(LerpPosInterval(i, timeForDrop, i.getPos(), name=self.taskName('ToSuitAnim') + '-' + str(sideBldgNodes.index(i))))
if not soundPlayed:
showTrack.append(Func(base.playSfx, self.cogLandSound, 0, 1, None, 0.0))
showTrack.append(self.createBounceTrack(i, 2, 0.65, TO_SUIT_BLDG_TIME - timeForDrop, slowInitBounce=1.0))
if not soundPlayed:
showTrack.append(Func(base.playSfx, self.cogSettleSound, 0, 1, None, 0.0))
tracks.append(showTrack)
if not soundPlayed:
soundPlayed = 1
elif name[0] == 't':
hideTrack = Sequence(name=self.taskName('ToSuitToonFlatsTrack'))
timeTillSquish = (self.SUIT_INIT_HEIGHT - 20.0) / self.SUIT_INIT_HEIGHT
timeTillSquish *= timeForDrop
hideTrack.append(LerpFunctionInterval(self.adjustColorScale, fromData=1, toData=0.25, duration=timeTillSquish, extraArgs=[i]))
hideTrack.append(LerpScaleInterval(i, timeForDrop - timeTillSquish, Vec3(1, 1, 0.01)))
hideTrack.append(Func(i.stash))
hideTrack.append(Func(i.setScale, Vec3(1)))
hideTrack.append(Func(i.clearColorScale))
tracks.append(hideTrack)
self.stopTransition()
self._deleteTransitionTrack()
self.transitionTrack = tracks
self.transitionTrack.start(timeStamp)
return
def showSuitsFalling(self, suits, ts, name, callback):
if self.bossCog is None:
return
suitTrack = Parallel()
delay = 0
for suit in suits:
suit.setState('Battle')
if suit.dna.dept == 'l':
suit.reparentTo(self.bossCog)
suit.setPos(0, 0, 0)
if suit in self.joiningSuits:
i = len(self.pendingSuits) + self.joiningSuits.index(suit)
destPos, h = self.suitPendingPoints[i]
destHpr = VBase3(h, 0, 0)
else:
destPos, destHpr = self.getActorPosHpr(suit, self.suits)
startPos = destPos + Point3(0, 0, SuitTimings.fromSky *
ToontownGlobals.SuitWalkSpeed)
self.notify.debug('startPos for %s = %s' % (suit, startPos))
suit.reparentTo(self)
suit.setPos(startPos)
suit.headsUp(self)
moveIval = Sequence()
chairInfo = self.bossCog.claimOneChair()
if chairInfo:
moveIval = self.createDinerMoveIval(suit, destPos, chairInfo)
suitTrack.append(
Track(
(delay,
Sequence(
moveIval,
Func(
suit.loop,
'neutral')))))
delay += 1
if self.hasLocalToon():
camera.reparentTo(self)
self.notify.debug('self.battleSide =%s' % self.battleSide)
camHeading = -20
camX = -4
if self.battleSide == 0:
camHeading = 20
camX = 4
camera.setPosHpr(camX, -15, 7, camHeading, 0, 0)
done = Func(callback)
track = Sequence(suitTrack, done, name=name)
track.start(ts)
self.storeInterval(track, name)
return
def construct(self):
track = Sequence()
# First, set the avatar's initial rotational components:
track.append(Func(self.avatar.setQuat, self.quatA))
# Next, construct the rotate track:
rotateTrack = Parallel()
if self.animName is not None:
rotateTrack.append(
Func(self.avatar.setPlayRate, self.animPlayRate, self.animName)
)
rotateTrack.append(Func(self.avatar.loop, self.animName))
if self.sfx is not None:
rotateTrack.append(
Func(base.playSfx, self.sfx, looping=1, node=self.avatar)
)
rotateTrack.append(self.getQuatInterval())
track.append(rotateTrack)
# Finally, clean up what is necessary:
if self.animName is not None:
track.append(Func(self.avatar.setPlayRate, 1, self.animName))
if self.sfx is not None:
track.append(Func(self.sfx.stop))
return track
def showVisibleSquares(self, dt="default"): visibles = defaultdict(lambda: False) for p in [(x,y) for (x,y) in self.pieces if 0 <= x < 8 and 0 <= y < 8]: if self.pieces[p]: if self.pieces[p].color == self.player: for s in self.pieces[p].visibleSquares(self.pieces): visibles[s] = True par = Parallel() for s in self.squares: if visibles[s]: par.append(self.showSquare(s, dt)) else: par.append(self.hideSquare(s, dt)) par.start() return par
def move_camp_unit(self, sens):
if self.nb_saves == 0 or self.nb_saves == 1: return
if sens == 2: #capture depuis le click souris
if self.app.lst_arrows[2]["status"] == 2: sens = 0
elif self.app.lst_arrows[3]["status"] == 2: sens = 1
else: return
pos_texts = [(0.3, 0, 0.2), (0, 0, 0), (0.3, 0, -0.5), (0.4, 0, -0.6),
(0.5, 0, -0.68)]
scale_texts = [0.08, 0.1, 0.08, 0.07, 0.05]
if sens == 0 and self.lst_menus[2] == (self.nb_saves - 1): return
elif sens == 1 and self.lst_menus[2] == 0: return
if sens == 0:
if self.lst_menus[2] == 0: self.app.lst_arrows[3]["node"].show()
if self.lst_menus[2] == (self.nb_saves - 2):
self.app.lst_arrows[2]["node"].hide()
if self.lst_menus[2] > 0:
self.gui_saves[self.lst_menus[2] - 1][4].hide()
if self.lst_menus[2] + 4 < self.nb_saves:
self.gui_saves[self.lst_menus[2] + 4][4].show()
self.arc_aux_menu.play("down")
self.lst_menus[2] += 1
elif sens == 1:
if self.lst_menus[2] == 1: self.app.lst_arrows[3]["node"].hide()
if self.lst_menus[2] == (self.nb_saves - 1):
self.app.lst_arrows[2]["node"].show()
if self.lst_menus[2] > 1:
self.gui_saves[self.lst_menus[2] - 2][4].show()
if self.lst_menus[2] + 3 < self.nb_saves:
self.gui_saves[self.lst_menus[2] + 3][4].hide()
self.arc_aux_menu.play("up")
self.lst_menus[2] -= 1
self.lst_gui["camp_frame"][10]["text"] = self.gui_saves[
self.lst_menus[2]][2]
self.lst_gui["camp_frame"][11]["text"] = self.gui_saves[
self.lst_menus[2]][1]
movePara = Parallel(name="texts_move")
start = (1 if self.lst_menus[2] == 0 else 0)
end = (self.nb_saves - self.lst_menus[2] + 1 if
(self.nb_saves - self.lst_menus[2]) < 5 else 5)
for it in range(start, end):
movePara.append(self.gui_saves[self.lst_menus[2] - 1 + start +
(it - start)][4].posInterval(
0.2, Point3(pos_texts[it])))
movePara.append(self.gui_saves[self.lst_menus[2] - 1 + start +
(it - start)][4].scaleInterval(
0.2, scale_texts[it]))
movePara.start()
def showSquare(self, sq, dt="default", callback=None): if self.squares[sq] and not self.isVisible(sq): if dt == "default": dt = 1.0 par = Parallel( LerpFunctionInterval(self.squares[sq].setAlphaScale, toData=1.0, fromData=0.0, duration=dt), ) if self.pieces[sq]: par.append(LerpFunctionInterval(self.pieces[sq].obj.setAlphaScale, toData=1.0, fromData=0.0, duration=dt)) s = Sequence(par) if callback: s.append(Func(callback)) return s else: s = Sequence() if callback: s.append(Func(callback)) return s
def createAnimAndSoundIval(self, animKey):
animIval = self.node.actorInterval(animKey)
animIvalDuration = animIval.getDuration()
origAnimName = self.node.getAnimFilename(animKey)
soundIval = self.createSoundInterval(origAnimName, animIvalDuration)
soundIvalDuration = soundIval.getDuration()
printFunc = Func(self.printAnimIfClose, animKey)
if self.hasSpecialIval(origAnimName):
specialIval = self.getSpecialIval(origAnimName)
idleAnimAndSound = Parallel(animIval, soundIval, specialIval)
if base.config.GetBool('interactive-prop-info', False):
idleAnimAndSound.append(printFunc)
else:
idleAnimAndSound = Parallel(animIval, soundIval)
if base.config.GetBool('interactive-prop-info', False):
idleAnimAndSound.append(printFunc)
return idleAnimAndSound
def createAnimAndSoundIval(self, animKey):
animIval = self.node.actorInterval(animKey)
animIvalDuration = animIval.getDuration()
origAnimName = self.node.getAnimFilename(animKey)
soundIval = self.createSoundInterval(origAnimName, animIvalDuration)
soundIvalDuration = soundIval.getDuration()
printFunc = Func(self.printAnimIfClose, animKey)
if self.hasSpecialIval(origAnimName):
specialIval = self.getSpecialIval(origAnimName)
idleAnimAndSound = Parallel(animIval, soundIval, specialIval)
if base.config.GetBool('interactive-prop-info', False):
idleAnimAndSound.append(printFunc)
else:
idleAnimAndSound = Parallel(animIval, soundIval)
if base.config.GetBool('interactive-prop-info', False):
idleAnimAndSound.append(printFunc)
return idleAnimAndSound
def showSuitsFalling(self, suits, ts, name, callback):
if self.bossCog is None:
return
suitTrack = Parallel()
delay = 0
for suit in suits:
suit.makeWaiter()
suit.setState('Battle')
if suit.dna.dept == 'l':
suit.reparentTo(self.bossCog)
suit.setPos(0, 0, 0)
if suit in self.joiningSuits:
i = len(self.pendingSuits) + self.joiningSuits.index(suit)
destPos, h = self.suitPendingPoints[i]
destHpr = VBase3(h, 0, 0)
else:
destPos, destHpr = self.getActorPosHpr(suit, self.suits)
startPos = destPos + Point3(0, 0, SuitTimings.fromSky *
ToontownGlobals.SuitWalkSpeed)
self.notify.debug('startPos for %s = %s' % (suit, startPos))
suit.reparentTo(self)
suit.setPos(startPos)
suit.headsUp(self)
flyIval = suit.beginSupaFlyMove(destPos, True, 'flyIn')
suitTrack.append(
Track(
(delay,
Sequence(
flyIval,
Func(
suit.loop,
'neutral')))))
delay += 1
if self.hasLocalToon():
camera.reparentTo(self)
if random.choice([0, 1]):
camera.setPosHpr(20, -4, 7, 60, 0, 0)
else:
camera.setPosHpr(-20, -4, 7, -60, 0, 0)
done = Func(callback)
track = Sequence(suitTrack, done, name=name)
track.start(ts)
self.storeInterval(track, name)
return
def createAnimAndSoundIval(self, animKey):
"""Return an interval for the anim animKey and sound, or just the anim as appropriate."""
animIval = self.node.actorInterval(animKey)
animIvalDuration = animIval.getDuration()
origAnimName = self.node.getAnimFilename(animKey)
soundIval = self.createSoundInterval( origAnimName, animIvalDuration)
soundIvalDuration = soundIval.getDuration()
printFunc = Func(self.printAnimIfClose, animKey)
if self.hasSpecialIval(origAnimName):
# used in mailbox with pie delivery
specialIval = self.getSpecialIval(origAnimName)
idleAnimAndSound = Parallel( animIval, soundIval, specialIval)
if base.config.GetBool("interactive-prop-info", False):
idleAnimAndSound.append(printFunc)
else:
idleAnimAndSound = Parallel( animIval, soundIval)
if base.config.GetBool("interactive-prop-info", False):
idleAnimAndSound.append(printFunc)
return idleAnimAndSound
def hide(self):
if self.__hidden:
return
self.__hidden = True
if not (self.__fading and self.__fadingDuration):
NodePath.hide(self)
self.removeFocus()
if self.__mask:
self.__mask.hide()
if self.__bgPath:
self.__bgPath.hide()
if self.__hiddenFunc:
self.__hiddenFunc(*self.__eventExtraArgs)
else:
#self.removeFocus()
if self.__currentInterval:
self.__currentInterval.pause()
endpos = tuple(map(operator.add,self.__originPos,self.__fadingPositionOffset))
parallel = Parallel(LerpFunc(_modifyAlphaScale,self.__fadingDuration,1,0,blendType = 'easeIn',extraArgs = [self]),
LerpPosInterval(self,self.__fadingDuration,
endpos,
self.__originPos,
blendType = 'easeIn'),
)
if self.__bgPath:
parallel.append(LerpFunc(_modifyAlphaScale,self.__fadingDuration,1,0,blendType = 'easeIn',extraArgs = [self.__bgPath]))
self.__currentInterval = Sequence(parallel,
Func(NodePath.hide,self),
Func(self.removeFocus),
)
if self.__mask:
self.__currentInterval.append(Func(self.__mask.hide))
if self.__bgPath:
self.__currentInterval.append(Func(self.__bgPath.hide))
if self.__hiddenFunc:
self.__currentInterval.append(Func(self.__hiddenFunc,*self.__eventExtraArgs))
self.__currentInterval.start()
def showSuitsFalling(self, suits, ts, name, callback):
if self.bossCog == None:
return None
suitTrack = Parallel()
delay = 0
for suit in suits:
suit.makeWaiter()
suit.setState('Battle')
if suit.dna.dept == 'l':
suit.reparentTo(self.bossCog)
suit.setPos(0, 0, 0)
if suit in self.joiningSuits:
i = len(self.pendingSuits) + self.joiningSuits.index(suit)
(destPos, h) = self.suitPendingPoints[i]
destHpr = VBase3(h, 0, 0)
else:
(destPos, destHpr) = self.getActorPosHpr(suit, self.suits)
startPos = destPos + Point3(0, 0, SuitTimings.fromSky * ToontownGlobals.SuitWalkSpeed)
self.notify.debug('startPos for %s = %s' % (suit, startPos))
suit.reparentTo(self)
suit.setPos(startPos)
suit.headsUp(self)
flyIval = suit.beginSupaFlyMove(destPos, True, 'flyIn')
suitTrack.append(Track((delay, Sequence(flyIval, Func(suit.loop, 'neutral')))))
delay += 1
if self.hasLocalToon():
camera.reparentTo(self)
if random.choice([
0,
1]):
camera.setPosHpr(20, -4, 7, 60, 0, 0)
else:
camera.setPosHpr(-20, -4, 7, -60, 0, 0)
done = Func(callback)
track = Sequence(suitTrack, done, name = name)
track.start(ts)
self.storeInterval(track, name)
def __getCloudTrack(cloud, useEffect = 1):
track = Sequence(Func(cloud.pose, 'chan', 0), LerpScaleInterval(cloud, 1.5, scaleUpPoint, startScale=GagGlobals.PNT3NEAR0), Wait(rainDelay))
if useEffect == 1:
pTrack = Parallel()
delay = trickleDuration = cloudHold * 0.25
trickleTrack = ParticleInterval(trickleFx, cloud, worldRelative=0, duration=trickleDuration, cleanup=True)
track.append(trickleTrack)
for i in range(0, 3):
dur = cloudHold - 2 * trickleDuration
pTrack.append(Sequence(Wait(delay), ParticleInterval(rainEffects[i], cloud, worldRelative=0, duration=dur, cleanup=True)))
delay += effectDelay
pTrack.append(Sequence(Wait(3 * effectDelay), ActorInterval(cloud, 'chan', startTime=1, duration=cloudHold)))
damageTrack = Sequence()
if cog.getHealth() - self.getDamage() <= 0:
damageTrack.append(Func(cog.d_disableMovement, wantRay=True))
damageTrack.append(Func(damageCog))
else:
damageTrack.append(Wait(tContact))
damageTrack.append(Func(damageCog))
pTrack.append(damageTrack)
track.append(pTrack)
else:
track.append(ActorInterval(cloud, 'chan', startTime=1, duration=cloudHold))
track.append(LerpScaleInterval(cloud, 0.5, GagGlobals.PNT3NEAR0))
track.append(Func(GagUtils.destroyProp, cloud))
return track
def handleMatch(self, cardA, cardB, withBonus):
self.notify.debug('we got a match %d %d' % (cardA, cardB))
self.matches += 1
if cardA in self.faceUpList:
self.faceUpList.remove(cardA)
if cardB in self.faceUpList:
self.faceUpList.remove(cardB)
self.inactiveList.append(cardA)
self.inactiveList.append(cardB)
matchIval = Parallel()
for card in [cardA, cardB]:
self.cards[card].setTransparency(1)
cardSeq = Sequence(
LerpColorScaleInterval(self.cards[card],
duration=1,
colorScale=Vec4(1.0, 1.0, 1.0, 0.0)),
Func(self.cards[card].hide))
matchIval.append(cardSeq)
if withBonus:
matchIval.append(
SoundInterval(self.matchWithBonusSfx,
node=self.cards[card],
listenerNode=base.localAvatar,
cutOff=240))
else:
matchIval.append(
SoundInterval(self.matchSfx,
node=self.cards[card],
listenerNode=base.localAvatar,
cutOff=240))
matchIval.start()
if len(self.inactiveList) == len(self.cards):
self.sendUpdate('reportDone')
def startEntity(self, cog):
if not cog:
self.completeSquirt()
return
scaleUpPoint = Point3(1.5, 1.5, 1.5)
rainDelay = 1
effectDelay = 0.3
cloudHold = 4.7
tContact = 2.4
if cog.isDead():
cloudHold = 1.7
cloud01, trickleFx, rainEffects, entity = self.buildEntity()
cloud01.setZ(cog.suitPlan.getNametagZ() + 2)
cloud01.reparentTo(cog)
cloud02 = Actor(self.model, {'chan': GagGlobals.getProp(4, 'stormcloud-chan')})
cloud02.reparentTo(cloud01)
def damageCog():
if self.isLocal():
self.avatar.sendUpdate('suitHitByPie', [cog.doId, self.getID()])
def __getCloudTrack(cloud, useEffect = 1):
track = Sequence(Func(cloud.pose, 'chan', 0), LerpScaleInterval(cloud, 1.5, scaleUpPoint, startScale=GagGlobals.PNT3NEAR0), Wait(rainDelay))
if useEffect == 1:
pTrack = Parallel()
delay = trickleDuration = cloudHold * 0.25
trickleTrack = ParticleInterval(trickleFx, cloud, worldRelative=0, duration=trickleDuration, cleanup=True)
track.append(trickleTrack)
for i in range(0, 3):
dur = cloudHold - 2 * trickleDuration
pTrack.append(Sequence(Wait(delay), ParticleInterval(rainEffects[i], cloud, worldRelative=0, duration=dur, cleanup=True)))
delay += effectDelay
pTrack.append(Sequence(Wait(3 * effectDelay), ActorInterval(cloud, 'chan', startTime=1, duration=cloudHold)))
damageTrack = Sequence()
if cog.getHealth() - self.getDamage() <= 0:
damageTrack.append(Func(cog.d_disableMovement, wantRay=True))
damageTrack.append(Func(damageCog))
else:
damageTrack.append(Wait(tContact))
damageTrack.append(Func(damageCog))
pTrack.append(damageTrack)
track.append(pTrack)
else:
track.append(ActorInterval(cloud, 'chan', startTime=1, duration=cloudHold))
track.append(LerpScaleInterval(cloud, 0.5, GagGlobals.PNT3NEAR0))
track.append(Func(GagUtils.destroyProp, cloud))
return track
tracks = Parallel()
soundTrack01 = self.getSoundTrack(1.3, self.avatar)
soundTrack02 = self.getSoundTrack(3.4, self.avatar)
tracks.append(soundTrack01)
tracks.append(soundTrack02)
cloud01Track = __getCloudTrack(cloud01)
cloud02Track = __getCloudTrack(cloud02, useEffect=0)
tracks.append(cloud01Track)
tracks.append(cloud02Track)
tracks.append(Func(self.destroyEntity, entity))
tracks.start()
def start(self):
SoundGag.start(self)
tracks = Parallel()
delayTime = 2.45
delayUntilAppearSound = 1.0
INSTRUMENT_SCALE_MODIFIER = 0.5
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(0.1, 0.1, 0.1)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(0.3, 0.3, 0.3)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.4, 0.4, 0.4)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
def setInstrumentStats():
self.gag.setPos(-0.8, -0.9, 0.2)
self.gag.setHpr(145, 0, 0)
self.gag.setScale(instrMin)
megaphoneSh = Sequence(
Func(self.placeProp, self.handJoint, self.megaphone),
Func(self.placeProp, self.handJoint, self.gag),
Func(setInstrumentStats))
grow = self.getScaleIntervals(self.gag,
duration=1,
startScale=instrMin,
endScale=instrMax1)
instrumentAppear = Parallel(grow)
stretchInstr = self.getScaleBlendIntervals(self.gag,
duration=0.3,
startScale=instrMax2,
endScale=instrStretch,
blendType='easeOut')
backInstr = self.getScaleBlendIntervals(self.gag,
duration=1.0,
startScale=instrStretch,
endScale=instrMin,
blendType='easeIn')
spinInstr = LerpHprInterval(self.gag,
duration=1.5,
startHpr=Vec3(145, 0, 0),
hpr=Vec3(145, 0, 90),
blendType='easeInOut')
attackTrack = Parallel(Sequence(Wait(0.2), spinInstr),
Sequence(stretchInstr, Wait(0.5), backInstr))
megaphoneTrack = Sequence(
megaphoneSh, Wait(delayUntilAppearSound),
SoundInterval(self.appearSfx, node=self.avatar),
Wait(delayTime + 1.0), instrumentAppear)
tracks.append(megaphoneTrack)
tracks.append(ActorInterval(self.avatar, 'sound'))
soundTrack = Sequence(
Wait(delayTime),
Parallel(attackTrack, SoundInterval(self.soundSfx,
node=self.avatar),
Func(self.damageCogsNearby), Wait(0.4),
Func(self.finish)))
tracks.append(soundTrack)
tracks.start()
self.tracks = tracks
def start(self):
SoundGag.start(self)
tracks = Parallel()
delayTime = 2.45
delayUntilAppearSound = 1.0
INSTRUMENT_SCALE_MODIFIER = 0.5
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(0.1, 0.1, 0.1)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(0.3, 0.3, 0.3)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.4, 0.4, 0.4)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
def setInstrumentStats():
self.gag.setPos(-0.8, -0.9, 0.2)
self.gag.setHpr(145, 0, 0)
self.gag.setScale(instrMin)
megaphoneSh = Sequence(Func(self.placeProp, self.handJoint, self.megaphone), Func(self.placeProp, self.handJoint, self.gag), Func(setInstrumentStats))
grow = self.getScaleIntervals(self.gag, duration=1, startScale=instrMin, endScale=instrMax1)
instrumentAppear = Parallel(grow)
stretchInstr = self.getScaleBlendIntervals(self.gag, duration=0.3, startScale=instrMax2, endScale=instrStretch, blendType='easeOut')
backInstr = self.getScaleBlendIntervals(self.gag, duration=1.0, startScale=instrStretch, endScale=instrMin, blendType='easeIn')
spinInstr = LerpHprInterval(self.gag, duration=1.5, startHpr=Vec3(145, 0, 0), hpr=Vec3(145, 0, 90), blendType='easeInOut')
attackTrack = Parallel(Sequence(Wait(0.2), spinInstr), Sequence(stretchInstr, Wait(0.5), backInstr))
megaphoneTrack = Sequence(megaphoneSh, Wait(delayUntilAppearSound), SoundInterval(self.appearSfx, node=self.avatar), Wait(delayTime + 1.0), instrumentAppear)
tracks.append(megaphoneTrack)
tracks.append(ActorInterval(self.avatar, 'sound'))
soundTrack = Sequence(Wait(delayTime), Parallel(attackTrack, SoundInterval(self.soundSfx, node=self.avatar), Func(self.damageCogsNearby), Wait(0.4), Func(self.finish)))
tracks.append(soundTrack)
tracks.start()
def handleMatch(self, cardA, cardB, withBonus):
self.notify.debug('we got a match %d %d' % (cardA, cardB))
self.matches += 1
if cardA in self.faceUpList:
self.faceUpList.remove(cardA)
if cardB in self.faceUpList:
self.faceUpList.remove(cardB)
self.inactiveList.append(cardA)
self.inactiveList.append(cardB)
matchIval = Parallel()
for card in [
cardA,
cardB]:
self.cards[card].setTransparency(1)
cardSeq = Sequence(LerpColorScaleInterval(self.cards[card], duration = 1, colorScale = Vec4(1.0, 1.0, 1.0, 0.0)), Func(self.cards[card].hide))
matchIval.append(cardSeq)
if withBonus:
matchIval.append(SoundInterval(self.matchWithBonusSfx, node = self.cards[card], listenerNode = base.localAvatar, cutOff = 240))
else:
matchIval.append(SoundInterval(self.matchSfx, node = self.cards[card], listenerNode = base.localAvatar, cutOff = 240))
matchIval.start()
if len(self.inactiveList) == len(self.cards):
self.sendUpdate('reportDone')
def start(self):
SoundGag.start(self)
INSTRUMENT_SCALE_MODIFIER = 0.5
delayTime = 2.45
delayUntilAppearSound = 1.0
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax = Vec3(0.2, 0.2, 0.2)
instrMax *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.25, 0.25, 0.25)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
def setInstrumentStats():
self.gag.setPos(-1.2, -1.3, 0.1)
self.gag.setHpr(145, 0, 85)
self.gag.setScale(instrMin)
megaphoneShow = Sequence(Func(self.placeProp, self.handJoint, self.megaphone), Func(self.placeProp, self.handJoint, self.gag), Func(setInstrumentStats))
grow = self.getScaleIntervals(self.gag, duration=0.2, startScale=instrMin, endScale=instrMax)
instrumentAppear = grow
stretchInstr = self.getScaleBlendIntervals(self.gag, duration=0.2, startScale=instrMax, endScale=instrStretch, blendType='easeOut')
backInstr = self.getScaleBlendIntervals(self.gag, duration=0.2, startScale=instrStretch, endScale=instrMax, blendType='easeIn')
attackTrack = Sequence(stretchInstr, backInstr)
megaphoneTrack = Sequence(megaphoneShow, Wait(delayUntilAppearSound), SoundInterval(self.appearSfx, node=self.avatar), instrumentAppear)
tracks.append(megaphoneTrack)
tracks.append(ActorInterval(self.avatar, 'sound'))
instrumentshrink = self.getScaleIntervals(self.gag, duration=0.1, startScale=instrMax, endScale=instrMin)
soundTrack = Sequence(Wait(delayTime), Parallel(attackTrack, SoundInterval(self.soundSfx, node=self.avatar), Wait(0.2), instrumentshrink, Func(self.damageCogsNearby), Wait(0.4), Func(self.finish)))
tracks.append(soundTrack)
tracks.start()
def __getCloudTrack(cloud, useEffect = 1):
track = Sequence(
Func(cloud.pose, 'chan', 0),
LerpScaleInterval(cloud, 1.5, scaleUpPoint, startScale = GagGlobals.PNT3NEAR0),
Wait(rainDelay)
)
if useEffect == 1:
pTrack = Parallel()
delay = trickleDuration = cloudHold * 0.25
trickleTrack = ParticleInterval(trickleFx, cloud, worldRelative=0, duration=trickleDuration, cleanup=True)
track.append(trickleTrack)
for i in range(0, 3):
dur = cloudHold - 2 * trickleDuration
pTrack.append(Sequence(Wait(delay), ParticleInterval(rainEffects[i], cloud, worldRelative=0, duration=dur, cleanup=True)))
delay += effectDelay
pTrack.append(Sequence(
Wait(3 * effectDelay),
ActorInterval(cloud, 'chan', startTime = 1, duration = cloudHold))
)
damageTrack = Sequence()
if cog.getHealth() - self.getDamage() <= 0:
damageTrack.append(Func(cog.d_disableMovement, wantRay = True))
damageTrack.append(Func(damageCog))
else:
damageTrack.append(Wait(tContact))
damageTrack.append(Func(damageCog))
pTrack.append(damageTrack)
track.append(pTrack)
else:
track.append(ActorInterval(cloud, 'chan', startTime = 1, duration = cloudHold))
track.append(LerpScaleInterval(cloud, 0.5, GagGlobals.PNT3NEAR0))
track.append(Func(GagUtils.destroyProp, cloud))
return track
def start(self):
SoundGag.start(self)
INSTRUMENT_SCALE_MODIFIER = 0.5
delayTime = 2.45
delayUntilAppearSound = 1.0
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax = Vec3(0.65, 0.65, 0.65)
instrMax *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.6, 1.1, 0.6)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
def setInstrumentStats():
self.gag.setPos(-1.1, -1.4, 0.1)
self.gag.setHpr(145, 0, 0)
self.gag.setScale(instrMin)
megaphoneShow = Sequence(Func(self.placeProp, self.handJoint, self.megaphone), Func(self.placeProp, self.handJoint, self.gag), Func(setInstrumentStats))
grow = self.getScaleIntervals(self.gag, duration=0.2, startScale=instrMin, endScale=instrMax)
instrumentAppear = grow
stretchInstr = self.getScaleBlendIntervals(self.gag, duration=0.2, startScale=instrMax, endScale=instrStretch, blendType='easeOut')
backInstr = self.getScaleBlendIntervals(self.gag, duration=0.2, startScale=instrStretch, endScale=instrMax, blendType='easeIn')
stretchMega = self.getScaleBlendIntervals(self.megaphone, duration=0.2, startScale=self.megaphone.getScale(), endScale=0.9, blendType='easeOut')
backMega = self.getScaleBlendIntervals(self.megaphone, duration=0.2, startScale=0.9, endScale=self.megaphone.getScale(), blendType='easeIn')
attackTrack = Parallel(Sequence(stretchInstr, backInstr), Sequence(stretchMega, backMega))
megaphoneTrack = Sequence(megaphoneShow, Wait(delayUntilAppearSound), SoundInterval(self.appearSfx, node=self.avatar), instrumentAppear)
tracks.append(megaphoneTrack)
tracks.append(ActorInterval(self.avatar, 'sound'))
instrumentshrink = self.getScaleIntervals(self.gag, duration=0.1, startScale=instrMax, endScale=instrMin)
soundTrack = Sequence(Wait(delayTime), Parallel(attackTrack, SoundInterval(self.soundSfx, node=self.avatar), Wait(0.2), instrumentshrink, Func(self.damageCogsNearby), Wait(0.4), Func(self.finish)))
tracks.append(soundTrack)
tracks.start()
self.tracks = tracks
def append(self,text,width,height,spacing = 0, fadein = 0, fadeinType = 0):
'''Add a NodePath that contains a generated text geom
This method is called by SogalText
'''
self.__lock.acquire()
self.items.append(text)
text.reparentTo(self)
textPos = self.currentPtr
text.setPos(textPos)
if fadein:
interval = Parallel()
if fadeinType == 0 or fadeinType == 'normal':
interval.append(LerpFunc(_modifyAlphaScale,fadein,0,1,blendType = 'easeOut',extraArgs = [text]))
if fadeinType == 1 or fadeinType == 'flyin':
interval.append(LerpFunc(_modifyAlphaScale,fadein,0,1,blendType = 'easeOut',extraArgs = [text]))
interval.append(LerpPosInterval(text,fadein,
self.currentPtr,
(self.currentPtr[0],self.currentPtr[1],self.currentPtr[2] -0.3),
blendType = 'easeOut'))
interval.start()
self.__lerpIntervals.append(interval)
self.lineWidth = self.currentPtr[0] + width
self.lineHeight = max(height, self.lineHeight)
self.currentPtr = (self.lineWidth + spacing, 0, 0)
self.__lock.release()
def start(self):
SoundGag.start(self)
tracks = Parallel()
delay = 2.45
INSTRUMENT_SCALE_MODIFIER = 0.5
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(1.7, 1.7, 1.7)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(2.2, 2.2, 2.2)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.4, 0.4, 0.4)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
head = self.gag.find('**/opera_singer')
head.setPos(0, 0, 0)
def setInstrumentStats():
newPos = Vec3(-0.8, -0.9, 0.2)
newPos *= 1.3
self.gag.setPos(newPos[0], newPos[1], newPos[2])
self.gag.setHpr(145, 0, 90)
self.gag.setScale(instrMin)
megaphoneShow = Sequence(Func(self.placeProp, self.handJoint, self.megaphone), Func(self.placeProp, self.handJoint, self.gag), Func(setInstrumentStats))
grow1 = self.getScaleBlendIntervals(self.gag, duration=1, startScale=instrMin, endScale=instrMax1, blendType='easeOut')
grow2 = self.getScaleBlendIntervals(self.gag, duration=1.1, startScale=instrMax1, endScale=instrMax2, blendType='easeIn')
shrink2 = self.getScaleIntervals(self.gag, duration=0.1, startScale=instrMax2, endScale=instrMin)
instrumentAppear = Parallel(Sequence(grow1, grow2, Wait(6.0), shrink2, Wait(0.4), Func(self.finish)), SoundInterval(self.appearSfx, node=self.avatar))
delayTime = delay
megaphoneTrack = Sequence(megaphoneShow, Wait(delayTime + 1.0), instrumentAppear)
tracks.append(megaphoneTrack)
toonTrack = self.__createToonInterval(0)
tracks.append(toonTrack)
soundTrack = Sequence(Wait(delayTime), Parallel(SoundInterval(self.soundSfx, node=self.avatar), Func(self.damageCogsNearby)))
tracks.append(soundTrack)
tracks.start()
def createOnePlayerSequence(self, index, duration):
numVotes = self.votes[index]
direction = self.directions[index]
def ticketTicker(t,
label=self.entryList[index][direction + 1],
startVotes=0,
endVotes=numVotes):
label['text'] = str(int(t * endVotes + startVotes))
track = Parallel()
track.append(
Func(self.entryList[index][0].show, name='showName %d' % index))
track.append(
LerpFunc(ticketTicker,
duration=duration,
name='countVotes %d' % index))
startVotes = 0
for prev in xrange(index):
if self.directions[prev] == direction:
startVotes += self.votes[prev]
def totalTicker(t,
label=self.totalVotesLabels[direction],
startVotes=startVotes,
additionalVotes=numVotes):
label['text'] = str(int(t * additionalVotes + startVotes))
track.append(
LerpFunc(totalTicker,
duration=duration,
name='countTotal %d' % index))
return track
def show(self):
if not self.__hidden:
return
self.__hidden = False
if self.__mask or self.__bgPath:
if self.__mask:
self.__mask.reparentTo(aspect2d,sort = self.getSort())
self.__mask.show()
if self.__bgPath:
self.__bgPath.reparentTo(aspect2d,sort = self.getSort())
self.__bgPath.show()
self.reparentTo(self.getParent(),sort = self.getSort())
if not (self.__fading and self.__fadingDuration):
NodePath.show(self)
self.requestFocus()
if self.__shownFunc:
self.__shownFunc(*self.__eventExtraArgs)
else:
NodePath.show(self)
self.requestFocus()
if self.__currentInterval:
self.__currentInterval.pause()
pos = tuple(map(operator.add,self.__originPos,self.__fadingPositionOffset))
parallel = Parallel(LerpFunc(_modifyAlphaScale,self.__fadingDuration,0,1,blendType = 'easeOut',extraArgs = [self]),
LerpPosInterval(self,self.__fadingDuration,
self.__originPos,
pos,
blendType = 'easeOut')
)
if self.__bgPath:
parallel.append(LerpFunc(_modifyAlphaScale,self.__fadingDuration,0,1,blendType = 'easeOut',extraArgs = [self.__bgPath]))
self.__currentInterval = Sequence(parallel)
if self.__shownFunc:
self.__currentInterval.append(Func(self.__shownFunc, *self.__eventExtraArgs))
self.__currentInterval.start()
def start(self):
SoundGag.start(self)
INSTRUMENT_SCALE_MODIFIER = 0.5
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax = Vec3(0.4, 0.4, 0.4)
instrMax *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.5, 0.5, 0.5)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
def setInstrumentStats():
self.gag.setPos(-1.3, -1.4, 0.1)
self.gag.setHpr(145, 0, 85)
self.gag.setScale(instrMin)
def longshake(models, num):
inShake = self.getScaleBlendIntervals(models, duration=0.2, startScale=instrMax, endScale=instrStretch, blendType='easeInOut')
outShake = self.getScaleBlendIntervals(models, duration=0.2, startScale=instrStretch, endScale=instrMax, blendType='easeInOut')
i = 1
seq = Sequence()
while i < num:
if i % 2 == 0:
seq.append(inShake)
else:
seq.append(outShake)
i += 1
seq.start()
megaphoneShow = Sequence(Func(self.placeProp, self.handJoint, self.megaphone), Func(self.placeProp, self.handJoint, self.gag), Func(setInstrumentStats))
grow = self.getScaleBlendIntervals(self.gag, duration=1, startScale=instrMin, endScale=instrMax, blendType='easeInOut')
instrumentshrink = self.getScaleIntervals(self.gag, duration=0.1, startScale=instrMax, endScale=instrMin)
instrumentAppear = Sequence(grow, Wait(0), Func(longshake, self.gag, 5))
megaphoneTrack = Parallel(Sequence(Wait(1.7), SoundInterval(self.soundSfx, node=self.avatar)), Sequence(megaphoneShow, Wait(1.7), instrumentAppear, Wait(1),
Func(self.damageCogsNearby), instrumentshrink, Wait(0.4), Func(self.finish)))
tracks.append(megaphoneTrack)
tracks.append(self.getSingularAnimTrack('sound'))
tracks.start()
self.tracks = tracks
def getAvatarEnterTrack(self, av):
track = Sequence(name=av.uniqueName('avatarEnterDoorTrack'))
track.append(Func(av.setAnimState, 'walkBack'))
track.append(
ParallelEndTogether(
LerpPosInterval(av,
duration=0.5,
pos=self.enterDoorWalkBackNode.getPos(render),
startPos=av.getPos(render)),
LerpQuatInterval(av,
duration=0.5,
quat=self.enterDoorWalkInNode.getHpr(render),
startHpr=av.getHpr(render))))
track.append(Func(av.setPlayRate, 1.0, 'walk'))
track.append(Func(av.loop, 'neutral'))
track.append(Wait(1.0))
track.append(Func(av.loop, 'walk'))
parallel = Parallel()
parallel.append(
LerpPosInterval(
av,
duration=1.0,
pos=self.enterDoorWalkInNode.getPos(render),
startPos=self.enterDoorWalkBackNode.getPos(render)))
if base.localAvatar.doId == av.doId:
parallel.append(
Sequence(
Wait(0.5),
Func(messenger.send,
'DistributedDoor_localAvatarGoingInDoor'), Wait(1.0)))
track.append(parallel)
if base.localAvatar.doId == av.doId:
track.append(
Func(messenger.send, 'DistributedDoor_localAvatarWentInDoor'))
track.setDoneEvent(track.getName())
track.delayDelete = DelayDelete.DelayDelete(av, track.getName())
self.acceptOnce(track.getDoneEvent(), self.__avatarTrackDone, [track])
return track
def start(self):
SoundGag.start(self)
INSTRUMENT_SCALE_MODIFIER = 0.5
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax = Vec3(0.4, 0.4, 0.4)
instrMax *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.5, 0.5, 0.5)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
def setInstrumentStats():
self.gag.setPos(-1.3, -1.4, 0.1)
self.gag.setHpr(145, 0, 85)
self.gag.setScale(instrMin)
def longshake(models, num):
inShake = self.getScaleBlendIntervals(models, duration=0.2, startScale=instrMax, endScale=instrStretch, blendType='easeInOut')
outShake = self.getScaleBlendIntervals(models, duration=0.2, startScale=instrStretch, endScale=instrMax, blendType='easeInOut')
i = 1
seq = Sequence()
while i < num:
if i % 2 == 0:
seq.append(inShake)
else:
seq.append(outShake)
i += 1
seq.start()
megaphoneShow = Sequence(Func(self.placeProp, self.handJoint, self.megaphone), Func(self.placeProp, self.handJoint, self.gag), Func(setInstrumentStats))
grow = self.getScaleBlendIntervals(self.gag, duration=1, startScale=instrMin, endScale=instrMax, blendType='easeInOut')
instrumentshrink = self.getScaleIntervals(self.gag, duration=0.1, startScale=instrMax, endScale=instrMin)
instrumentAppear = Sequence(grow, Wait(0), Func(longshake, self.gag, 5))
megaphoneTrack = Parallel(Sequence(Wait(1.7), SoundInterval(self.soundSfx, node=self.avatar)), Sequence(megaphoneShow, Wait(1.7), instrumentAppear, Wait(1), Func(self.damageCogsNearby), instrumentshrink, Wait(0.4), Func(self.finish)))
tracks.append(megaphoneTrack)
tracks.append(ActorInterval(self.avatar, 'sound'))
tracks.start()
def startMovie(self):
self.movie = Sequence()
for index in range(self.numPlayers):
track = self.createOnePlayerSequence(index, 1.25)
self.movie.append(track)
self.movie.append(Wait(0.75))
self.movie.append(Func(self.resultLabel.show))
soundAndWait = Parallel()
soundAndWait.append(Wait(2.0))
if self.localAvatarWon:
soundAndWait.append(SoundInterval(self.winVoteSfx))
elif self.localAvatarLost:
soundAndWait.append(SoundInterval(self.loseVoteSfx, duration=0.43))
self.movie.append(soundAndWait)
self.movie.start()
def construct(self):
track = Sequence()
# Construct the walk track:
walkTrack = Parallel()
if self.animName is not None:
walkTrack.append(Func(self.avatar.setPlayRate, self.animPlayRate, self.animName))
walkTrack.append(Func(self.avatar.loop, self.animName))
if self.sfx is not None:
walkTrack.append(Func(base.playSfx, self.sfx, looping=1, node=self.avatar))
walkTrack.append(Func(taskMgr.add, self.step, self.stepTaskName, 25))
track.append(walkTrack)
# Wait the duration, and then stop the step task:
track.append(Wait(self.duration))
track.append(Func(taskMgr.remove, self.stepTaskName))
# Finally, clean up what is necessary:
if self.animName is not None:
track.append(Func(self.avatar.setPlayRate, 1, self.animName))
if self.sfx is not None:
track.append(Func(self.sfx.stop))
return track
def createOnePlayerSequence(self, index, duration):
numVotes = self.votes[index]
direction = self.directions[index]
def ticketTicker(t, label = self.entryList[index][direction + 1], startVotes = 0, endVotes = numVotes):
label['text'] = str(int(t * endVotes + startVotes))
track = Parallel()
track.append(Func(self.entryList[index][0].show, name='showName %d' % index))
track.append(LerpFunc(ticketTicker, duration=duration, name='countVotes %d' % index))
startVotes = 0
for prev in range(index):
if self.directions[prev] == direction:
startVotes += self.votes[prev]
def totalTicker(t, label = self.totalVotesLabels[direction], startVotes = startVotes, additionalVotes = numVotes):
label['text'] = str(int(t * additionalVotes + startVotes))
track.append(LerpFunc(totalTicker, duration=duration, name='countTotal %d' % index))
return track
def start(self):
SoundGag.start(self)
tracks = Parallel()
INSTRUMENT_SCALE_MODIFIER = 0.5
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(0.3, 0.4, 0.2)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(0.3, 0.3, 0.3)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch1 = Vec3(0.3, 0.5, 0.25)
instrStretch1 *= INSTRUMENT_SCALE_MODIFIER
instrStretch2 = Vec3(0.3, 0.7, 0.3)
instrStretch2 *= INSTRUMENT_SCALE_MODIFIER
def setInstrumentStats():
self.gag.setPos(-0.6, -0.9, 0.15)
self.gag.setHpr(145, 0, 85)
self.gag.setScale(instrMin)
megaphoneShow = Sequence(Func(self.placeProp, self.handJoint, self.megaphone), Func(self.placeProp, self.handJoint, self.gag), Func(setInstrumentStats))
grow1 = self.getScaleIntervals(self.gag, duration=0.3, startScale=instrMin, endScale=instrMax1)
grow2 = self.getScaleIntervals(self.gag, duration=0.3, startScale=instrMax1, endScale=instrMax2)
instrumentAppear = Parallel(Sequence(grow1, grow2))
stretchInstr1 = self.getScaleBlendIntervals(self.gag, duration=0.1, startScale=instrMax2, endScale=instrStretch1, blendType='easeOut')
stretchInstr2 = self.getScaleBlendIntervals(self.gag, duration=0.1, startScale=instrStretch1, endScale=instrStretch2, blendType='easeOut')
stretchInstr = Sequence(stretchInstr1, stretchInstr2)
backInstr = self.getScaleBlendIntervals(self.gag, duration=0.1, startScale=instrStretch2, endScale=instrMax2, blendType='easeOut')
attackTrack = Sequence(stretchInstr, Wait(1), backInstr)
delayTime = 2.45
delayUntilAppearSound = 1.0
megaphoneTrack = Sequence(megaphoneShow, Wait(delayUntilAppearSound), SoundInterval(self.appearSfx, node=self.avatar), Wait(delayTime + 1.0), instrumentAppear)
tracks.append(megaphoneTrack)
tracks.append(ActorInterval(self.avatar, 'sound'))
instrumentshrink = self.getScaleIntervals(self.gag, duration=0.1, startScale=instrMax2, endScale=instrMin)
soundTrack = Sequence(Wait(delayTime), Parallel(attackTrack, SoundInterval(self.soundSfx, node=self.avatar), Sequence(Wait(1.5), instrumentshrink), Func(self.damageCogsNearby), Wait(0.4), Func(self.finish)))
tracks.append(soundTrack)
tracks.start()
class HangUpAttack(Attack):
notify = directNotify.newCategory('HangUpAttack')
attack = 'hangup'
def __init__(self, attacksClass, suit):
Attack.__init__(self, attacksClass, suit)
self.phone = None
self.receiver = None
self.collNP = None
self.phoneSfx = None
self.hangupSfx = None
self.shootIval = None
self.cord = None
self.receiverOutCord = None
self.phoneOutCord = None
return
def loadAttack(self):
self.phone = loader.loadModel('phase_3.5/models/props/phone.bam')
self.phone.setHpr(0, 0, 180)
if self.suit.type == 'B':
self.phone.setPos(0.7, 0.15, 0)
elif self.suit.type == 'C':
self.phone.setPos(0.25, 0, 0)
self.receiver = loader.loadModel('phase_3.5/models/props/receiver.bam')
self.receiver.reparentTo(self.phone)
self.cord = Rope()
self.cord.ropeNode.setUseVertexColor(1)
self.cord.ropeNode.setUseVertexThickness(1)
self.cord.setup(3, ({'node': self.phone,
'point': (0.8, 0, 0.2),
'color': (0, 0, 0, 1),
'thickness': 1000}, {'node': self.phone,
'point': (2, 0, 0),
'color': (0, 0, 0, 1),
'thickness': 1000}, {'node': self.receiver,
'point': (1.1, 0.25, 0.5),
'color': (0, 0, 0, 1),
'thickness': 1000}), [])
self.cord.setH(180)
self.phoneSfx = base.audio3d.loadSfx('phase_3.5/audio/sfx/SA_hangup.mp3')
base.audio3d.attachSoundToObject(self.phoneSfx, self.phone)
self.hangupSfx = base.audio3d.loadSfx('phase_3.5/audio/sfx/SA_hangup_place_down.mp3')
base.audio3d.attachSoundToObject(self.hangupSfx, self.phone)
collSphere = CollisionSphere(0, 0, 0, 2)
collSphere.setTangible(0)
collNode = CollisionNode('phone_shootout')
collNode.addSolid(collSphere)
collNode.setCollideMask(CIGlobals.WallBitmask)
self.collNP = self.phone.attachNewNode(collNode)
def doAttack(self, ts = 0):
self.loadAttack()
if hasattr(self.suit, 'uniqueName'):
name = self.suit.uniqueName('doHangupAttack')
else:
name = 'doHangupAttack'
if self.suit.type == 'A':
delay2playSound = 1.0
delayAfterSoundToPlaceDownReceiver = 0.2
delayAfterShootToIgnoreCollisions = 1.0
delay2PickUpReceiver = 1.0
receiverInHandPos = Point3(-0.5, 0.5, -1)
elif self.suit.type == 'B':
delay2playSound = 1.5
delayAfterSoundToPlaceDownReceiver = 0.7
delayAfterShootToIgnoreCollisions = 1.0
delay2PickUpReceiver = 1.5
receiverInHandPos = Point3(-0.3, 0.5, -0.8)
elif self.suit.type == 'C':
delay2playSound = 1.0
delayAfterSoundToPlaceDownReceiver = 1.15
delayAfterShootToIgnoreCollisions = 1.0
delay2PickUpReceiver = 1.5
receiverInHandPos = Point3(-0.3, 0.5, -0.8)
self.suitTrack = Parallel(name=name)
self.suitTrack.append(ActorInterval(self.suit, 'phone'))
self.suitTrack.append(Sequence(Wait(delay2playSound), SoundInterval(self.phoneSfx, duration=2.1), Wait(delayAfterSoundToPlaceDownReceiver), Func(self.receiver.setPos, 0, 0, 0), Func(self.receiver.setH, 0.0), Func(self.receiver.reparentTo, self.phone), Func(self.acceptOnce, 'enter' + self.collNP.node().getName(), self.handleCollision), Func(self.shootOut), Parallel(SoundInterval(self.hangupSfx), Sequence(Wait(delayAfterShootToIgnoreCollisions), Func(self.ignore, 'enter' + self.collNP.node().getName())))))
self.suitTrack.append(Sequence(Func(self.phone.reparentTo, self.suit.find('**/joint_Lhold')), Func(self.cord.reparentTo, render), Wait(delay2PickUpReceiver), Func(self.receiver.reparentTo, self.suit.find('**/joint_Rhold')), Func(self.receiver.setPos, receiverInHandPos), Func(self.receiver.setH, 270.0)))
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 handleCollision(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)
def shootOut(self):
pathNode = NodePath('path')
pathNode.reparentTo(self.suit)
pathNode.setPos(0, 50, self.phone.getZ(self.suit))
self.collNP.reparentTo(render)
self.shootIval = LerpPosInterval(self.collNP, duration=1.0, pos=pathNode.getPos(render), startPos=self.phone.getPos(render))
self.shootIval.start()
pathNode.removeNode()
del pathNode
def cleanup(self):
Attack.cleanup(self)
if self.shootIval:
self.shootIval.pause()
self.shootIval = None
if self.cord:
self.cord.removeNode()
self.cord = None
if self.phone:
self.phone.removeNode()
self.phone = None
if self.receiver:
self.receiver.removeNode()
self.receiver = None
if self.collNP:
self.collNP.node().clearSolids()
self.collNP.removeNode()
self.collNP = None
if self.phoneSfx:
self.phoneSfx.stop()
self.phoneSfx = None
return
