def fadeIn(self, t=0.5, block=0):
"""
Play a fade in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the color
from black to transparent. When the color lerp is finished, it
parents the fade polygon to hidden. If block is set, return the
sequence instead of spawning it.
"""
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, FADE_SORT_INDEX)
if (t == 0):
# Fade in immediately with no lerp
self.fade.reparentTo(hidden)
else:
# Create a sequence that lerps the color out, then
# parents the fade to hidden
r = self.fadeColor[0]
g = self.fadeColor[1]
b = self.fadeColor[2]
task = Task.sequence(
self.fade.lerpColor(r, g, b, 1, r, g, b, 0, t),
Task.Task(self.__fadeInLerpDone))
# Spawn the sequence
if not block:
taskMgr.add(task, self.fadeTaskName)
else:
return task
def showHpString(self, text, duration=0.85, scale=0.7):
if self.HpTextEnabled and not self.ghostMode:
if text != '':
if self.hpText:
self.hideHpText()
self.HpTextGenerator.setFont(OTPGlobals.getSignFont())
self.HpTextGenerator.setText(text)
self.HpTextGenerator.clearShadow()
self.HpTextGenerator.setAlign(TextNode.ACenter)
r = a = 1.0
g = b = 0.0
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
self.hpText = self.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
self.hpText.setBillboardAxis()
self.hpText.setPos(0, 0, self.height / 2)
seq = Task.sequence(
self.hpText.lerpPos(Point3(0, 0, self.height + 1.5),
1.0,
blendType='easeOut'),
Task.pause(duration),
self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0),
0.1), Task.Task(self.hideHpTextTask))
taskMgr.add(seq, self.uniqueName('hpText'))
def irisIn(self, t=0.5, block=0):
"""
Play an iris in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris polygon up so it looks like we iris in. When the
scale lerp is finished, it parents the iris polygon to hidden.
If block is true, does not execute lerp, but returns the sequence.
"""
self.noTransitions()
self.loadIris()
if (t == 0):
self.iris.reparentTo(hidden)
else:
self.iris.reparentTo(aspect2d, FADE_SORT_INDEX)
self.iris.setScale(0.015)
# Create a sequence that scales the iris up,
# then parents the fade to hidden
task = Task.sequence(
self.iris.lerpScale(0.18, 0.18, 0.18, t, blendType="noBlend"),
Task.Task(self.__irisInLerpDone))
# Spawn the sequence
if not block:
taskMgr.add(task, self.irisTaskName)
else:
return task
def irisOut(self, t=0.5, block=0):
"""
Play an iris out transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris down so it looks like we iris out. When the scale
lerp is finished, it leaves the iris polygon covering the
aspect2d plane until you irisIn or call noIris.
"""
self.noTransitions()
self.loadIris()
self.loadFade() # we need this to cover up the hole.
if (t == 0):
self.iris.reparentTo(hidden)
else:
self.iris.reparentTo(aspect2d, FADE_SORT_INDEX)
self.iris.setScale(0.18)
# Create a sequence that scales the iris up,
# then parents the fade to hidden
task = Task.sequence(
self.iris.lerpScale(0.015,
0.015,
0.015,
t,
blendType="noBlend"),
Task.Task(self.irisOutLerpDone))
# Spawn the sequence
if not block:
taskMgr.add(task, self.irisTaskName)
else:
return task
def spawnTitleText(self):
def getDescription(zoneNum, self=self):
ent = self.entities.get(zoneNum)
if ent and hasattr(ent, "description"):
return ent.description
description = getDescription(self.lastCamZone)
if description and description != "":
taskMgr.remove(self.uniqueName("titleText"))
self.smallTitleText.setText(description)
self.titleText.setText(description)
self.titleText.setColor(Vec4(*self.titleColor))
self.titleText.setFg(self.titleColor)
titleSeq = None
if self.lastCamZone not in self.zonesEnteredList:
self.zonesEnteredList.append(self.lastCamZone)
titleSeq = Task.sequence(
Task.Task(self.hideSmallTitleTextTask),
Task.Task(self.showTitleTextTask),
Task.pause(0.10000000000000001),
Task.pause(6.0),
self.titleText.lerpColor(
Vec4(self.titleColor[0], self.titleColor[1], self.titleColor[2], self.titleColor[3]),
Vec4(self.titleColor[0], self.titleColor[1], self.titleColor[2], 0.0),
0.5,
),
)
smallTitleSeq = Task.sequence(Task.Task(self.hideTitleTextTask), Task.Task(self.showSmallTitleTask))
if titleSeq:
seq = Task.sequence(titleSeq, smallTitleSeq)
else:
seq = smallTitleSeq
taskMgr.add(seq, self.uniqueName("titleText"))
def showHpString(self, text, duration=0.84999999999999998, scale=0.69999999999999996):
if self.HpTextEnabled and not (self.ghostMode):
if text != "":
if self.hpText:
self.hideHpText()
self.HpTextGenerator.setFont(OTPGlobals.getSignFont())
self.HpTextGenerator.setText(text)
self.HpTextGenerator.clearShadow()
self.HpTextGenerator.setAlign(TextNode.ACenter)
r = 1.0
a = 1.0
g = 0.0
b = 0.0
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
self.hpText = self.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
self.hpText.setBillboardAxis()
self.hpText.setPos(0, 0, self.height / 2)
seq = Task.sequence(
self.hpText.lerpPos(Point3(0, 0, self.height + 1.5), 1.0, blendType="easeOut"),
Task.pause(duration),
self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0), 0.10000000000000001),
Task.Task(self.hideHpTextTask),
)
taskMgr.add(seq, self.uniqueName("hpText"))
def showHitScore(self, number, scale=1):
if number <= 0:
return
if self.hpText:
self.hideHitScore()
self.HpTextGenerator.setFont(ToontownGlobals.getSignFont())
if number < 0:
self.HpTextGenerator.setText(str(number))
else:
self.HpTextGenerator.setText('+' + str(number))
self.HpTextGenerator.clearShadow()
self.HpTextGenerator.setAlign(TextNode.ACenter)
r = 1
g = 1
b = 0
a = 1
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
self.hpText = render.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
self.hpText.setBillboardPointEye()
self.hpText.setBin('fixed', 100)
self.hpText.setPos(self.root, 0, 0, self.height / 2)
seq = Task.sequence(
self.hpText.lerpPos(Point3(
self.root.getX(render), self.root.getY(render),
self.root.getZ(render) + self.height + 1.0),
0.25,
blendType='easeOut'), Task.pause(0.25),
self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0), 0.1),
Task.Task(self.__hideHitScoreTask))
taskMgr.add(seq, 'PartyCogHpText' + str(self.id))
def _MakeAToon__handleNameShopDone(self):
self.guiLastButton.hide()
self.guiCheckButton.hide()
if self.ns.getDoneStatus() == 'last':
self.ns.hideAll()
self.hostTrack = Parallel(
self.charRunToLeft(char=self.host, comm=self.goToLastShop),
self.charRunToLeft(char=self.toon))
self.hostTrack.start()
elif self.ns.getDoneStatus() == 'paynow':
self.doneStatus = 'paynow'
def sendDoneTask(self):
messenger.send(self.doneEvent)
return Task.done
sdt = Task.Task(sendDoneTask)
sdt.doneEvent = self.doneEvent
base.transitions.fadeOut(finishIval=EventInterval(self.doneEvent))
else:
self.doneStatus = 'created'
def sendDoneTask(self):
messenger.send(self.doneEvent)
return Task.done
sdt = Task.Task(sendDoneTask)
sdt.doneEvent = self.doneEvent
base.transitions.fadeOut(finishIval=EventInterval(self.doneEvent))
def run(self):
"""Starts the main loop of the application."""
if PandaSystem.getPlatform() == 'emscripten':
return
# Set the clock to have last frame's time in case we were
# Paused at the prompt for a long time
t = self.globalClock.getFrameTime()
timeDelta = t - self.globalClock.getRealTime()
self.globalClock.setRealTime(t)
self.messenger.send("resetClock", [timeDelta])
if self.taskMgr.resumeFunc != None:
self.taskMgr.resumeFunc()
if self.taskMgr.stepping:
self.doRunFrame()
else:
self.taskMgr.running = True
while self.taskMgr.running:
try:
self.doRunFrame()
except KeyboardInterrupt:
self.taskMgr.stop()
except SystemError:
self.taskMgr.stop()
raise
except IOError as ioError:
code, _ = self.taskMgr.unpackIOError(ioError)
# Since upgrading to Python 2.4.1, pausing the execution
# often gives this IOError during the sleep function:
# IOError: [Errno 4] Interrupted function call
# So, let's just handle that specific exception and stop.
# All other IOErrors should still get raised.
# Only problem: legit IOError 4s will be obfuscated.
if code == 4:
self.taskMgr.stop()
else:
raise
except Exception as e:
if self.taskMgr.extendedExceptions:
self.taskMgr.stop()
Task.print_exc_plus()
else:
if (ExceptionVarDump.wantStackDumpLog
and ExceptionVarDump.dumpOnExceptionInit):
ExceptionVarDump._varDump__print(e)
raise
except:
if self.taskMgr.extendedExceptions:
self.taskMgr.stop()
Task.print_exc_plus()
else:
raise
self.taskMgr.mgr.stopThreads()
def spawnTitleText(self):
def getDescription(zoneNum, self=self):
ent = self.entities.get(zoneNum)
if ent and hasattr(ent, 'description'):
return ent.description
return None
description = getDescription(self.lastCamZone)
if description and description != '':
taskMgr.remove(self.uniqueName('titleText'))
self.smallTitleText.setText(description)
self.titleText.setText(description)
self.titleText.setColor(Vec4(*self.titleColor))
self.titleText.setFg(self.titleColor)
titleSeq = None
if self.lastCamZone not in self.zonesEnteredList:
self.zonesEnteredList.append(self.lastCamZone)
titleSeq = Task.sequence(
Task.Task(self.hideSmallTitleTextTask),
Task.Task(self.showTitleTextTask), Task.pause(0.1),
Task.pause(6.0),
self.titleText.lerpColor(
Vec4(self.titleColor[0], self.titleColor[1],
self.titleColor[2], self.titleColor[3]),
Vec4(self.titleColor[0], self.titleColor[1],
self.titleColor[2], 0.0), 0.5))
smallTitleSeq = Task.sequence(Task.Task(self.hideTitleTextTask),
Task.Task(self.showSmallTitleTask))
if titleSeq:
seq = Task.sequence(titleSeq, smallTitleSeq)
else:
seq = smallTitleSeq
taskMgr.add(seq, self.uniqueName('titleText'))
return
def showHpString(self, text, duration=0.85, scale=0.7):
if self.HpTextEnabled and not self.ghostMode:
# We don't show empty strings
if text != '':
# Get rid of text if it is already there.
if self.hpText:
self.hideHpText()
# Set the font
self.HpTextGenerator.setFont(OTPGlobals.getSignFont())
# Write the text
self.HpTextGenerator.setText(text)
# No shadow
self.HpTextGenerator.clearShadow()
# Put a shadow on there
#self.HpTextGenerator.setShadow(0.05, 0.05)
#self.HpTextGenerator.setShadowColor(0, 0, 0, 1)
# Center the text
self.HpTextGenerator.setAlign(TextNode.ACenter)
# Set the color and alpha scale (a)
r = a = 1.0
g = b = 0.0
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
# Put the hpText over the head of the avatar
self.hpText = self.attachNewNode(self.hpTextNode)
# Set its scale
self.hpText.setScale(scale)
# Make sure it is a billboard
self.hpText.setBillboardAxis()
# Initial position ... Center of the body... the "tan tien"
self.hpText.setPos(0, 0, self.height / 2)
seq = Task.sequence(
# Fly the number out of the character
self.hpText.lerpPos(Point3(0, 0, self.height + 1.5),
1.0,
blendType='easeOut'),
# Wait 2 seconds
Task.pause(duration),
# Fade the number
self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0),
0.1),
# Get rid of the number
Task.Task(self.hideHpTextTask))
taskMgr.add(seq, self.uniqueName("hpText"))
else:
# Just play the sound effect.
# TODO: Put in the sound effect!
pass
def showInfoText(self, text = 'hello world'):
description = text
if description and description != '':
taskMgr.remove(self.uniqueName('titleText'))
self.smallTitleText.setText(description)
self.titleText.setText(description)
self.titleText.setColor(Vec4(*self.titleColor))
self.titleText.setFg(self.titleColor)
titleSeq = None
titleSeq = Task.sequence(Task.Task(self.hideSmallTitleTextTask), Task.Task(self.showTitleTextTask), Task.pause(0.10000000000000001), Task.pause(3.0), self.titleText.lerpColor(Vec4(self.titleColor[0], self.titleColor[1], self.titleColor[2], self.titleColor[3]), Vec4(self.titleColor[0], self.titleColor[1], self.titleColor[2], 0.0), 0.5))
if titleSeq:
seq = Task.sequence(titleSeq)
taskMgr.add(seq, self.uniqueName('titleText'))
def showHpText(self, number, bonus=0, scale=1):
if self.HpTextEnabled and not (self.ghostMode):
if number != 0:
if self.hpText:
self.hideHpText()
self.HpTextGenerator.setFont(OTPGlobals.getSignFont())
if number < 0:
self.HpTextGenerator.setText(str(number))
else:
self.HpTextGenerator.setText('+' + str(number))
self.HpTextGenerator.clearShadow()
self.HpTextGenerator.setAlign(TextNode.ACenter)
if bonus == 1:
r = 1.0
g = 1.0
b = 0
a = 1
elif bonus == 2:
r = 1.0
g = 0.5
b = 0
a = 1
elif number < 0:
r = 0.90000000000000002
g = 0
b = 0
a = 1
else:
r = 0
g = 0.90000000000000002
b = 0
a = 1
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
self.hpText = self.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
self.hpText.setBillboardPointEye()
self.hpText.setBin('fixed', 100)
self.hpText.setPos(0, 0, self.height / 2)
seq = Task.sequence(
self.hpText.lerpPos(Point3(0, 0, self.height + 1.5),
1.0,
blendType='easeOut'),
Task.pause(0.84999999999999998),
self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0),
0.10000000000000001),
Task.Task(self.hideHpTextTask))
taskMgr.add(seq, self.uniqueName('hpText'))
def showHitScore(self, number, scale = 1):
if number <= 0:
return
if self.hpText:
self.hideHitScore()
self.HpTextGenerator.setFont(ToontownGlobals.getSignFont())
if number < 0:
self.HpTextGenerator.setText(str(number))
else:
self.HpTextGenerator.setText('+' + str(number))
self.HpTextGenerator.clearShadow()
self.HpTextGenerator.setAlign(TextNode.ACenter)
r = 1
g = 1
b = 0
a = 1
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
self.hpText = render.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
self.hpText.setBillboardPointEye()
self.hpText.setBin('fixed', 100)
self.hpText.setPos(self.root, 0, 0, self.height / 2)
seq = Task.sequence(self.hpText.lerpPos(Point3(self.root.getX(render), self.root.getY(render), self.root.getZ(render) + self.height + 1.0), 0.25, blendType='easeOut'), Task.pause(0.25), self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0), 0.1), Task.Task(self.__hideHitScoreTask))
taskMgr.add(seq, 'PartyCogHpText' + str(self.id))
def countdown(self, duration, callback = None, extraArgs = []):
self.countdownTask = Task.Task(self._timerTask)
self.countdownTask.duration = duration
self.countdownTask.callback = callback
self.countdownTask.extraArgs = extraArgs
taskMgr.remove('timerTask%s' % self.timerId)
return taskMgr.add(self.countdownTask, 'timerTask%s' % self.timerId)
def setCannonWillFire(self, cannonId, zRot, angle):
self.notify.debug('setCannonWillFire: %d %d %d' %
(cannonId, zRot, angle))
cannon = base.cr.doId2do.get(cannonId)
if cannon is None:
self.notify.warning(
"Cannon has not been created, but we got this message. Don't show firing."
)
return
if not cannon.getToonInside():
self.notify.warning(
"setCannonWillFire, but no toon insde. Don't show firing")
return
if self.isLocalToon(cannon.getToonInside()):
self.localFlyingToon = base.localAvatar
self.localFlyingToonId = base.localAvatar.doId
self.localFiringCannon = cannon
self.flyingToonCloudsHit = 0
cannon.updateModel(zRot, angle)
toonId = cannon.getToonInside().doId
task = Task.Task(self.__fireCannonTask)
task.toonId = toonId
task.cannon = cannon
taskMgr.add(task, self.taskNameFireCannon)
self.toonIds.append(toonId)
return
def irisOut(self, t=0.5, block=0):
"""
Play an iris out transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris down so it looks like we iris out. When the scale
lerp is finished, it leaves the iris polygon covering the
aspect2d plane until you irisIn or call noIris.
"""
self.noTransitions()
self.loadIris()
self.loadFade() # we need this to cover up the hole.
if (t == 0):
self.iris.reparentTo(hidden)
else:
self.iris.reparentTo(aspect2d, FADE_SORT_INDEX)
self.iris.setScale(0.18)
# Create a sequence that scales the iris up,
# then parents the fade to hidden
task = Task.sequence(
self.iris.lerpScale(0.015, 0.015, 0.015,
t, blendType="noBlend"),
Task.Task(self.irisOutLerpDone))
# Spawn the sequence
if not block:
taskMgr.add(task, self.irisTaskName)
else:
return task
def spawnHPanYZoom(self):
# Kill any existing tasks
taskMgr.remove('manipulateCamera')
# Spawn new task
t = Task.Task(self.HPanYZoomTask)
t.zoomSF = Vec3(self.coaMarker.getPos(SEditor.camera)).length()
taskMgr.add(t, 'manipulateCamera')
def irisIn(self, t=0.5, block=0):
"""
Play an iris in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris polygon up so it looks like we iris in. When the
scale lerp is finished, it parents the iris polygon to hidden.
If block is true, does not execute lerp, but returns the sequence.
"""
self.noTransitions()
self.loadIris()
if (t == 0):
self.iris.reparentTo(hidden)
else:
self.iris.reparentTo(aspect2d, FADE_SORT_INDEX)
self.iris.setScale(0.015)
# Create a sequence that scales the iris up,
# then parents the fade to hidden
task = Task.sequence(
self.iris.lerpScale(0.18, 0.18, 0.18,
t, blendType="noBlend"),
Task.Task(self.__irisInLerpDone))
# Spawn the sequence
if not block:
taskMgr.add(task, self.irisTaskName)
else:
return task
def enterActive(self, startTime):
self.root.setR(0.0)
updateTask = Task.Task(self.updateTask)
updateTask.startTime = startTime
taskMgr.add(updateTask, "PartyCog.update-%d" % self.id)
def spawnHPanYZoom(self):
# Kill any existing tasks
self.__stopManipulateCamera()
# Spawn new task
t = Task.Task(self.HPanYZoomTask)
t.zoomSF = Vec3(self.coaMarker.getPos(base.direct.camera)).length()
self.__startManipulateCamera(task=t)
def __lerp(self, functorFunc, duration, blendType, taskName=None):
"""
__lerp(self, functorFunc, float, string, string)
Basic lerp functionality used by other lerps.
Fire off a lerp. Make it a task if taskName given.
"""
# functorFunc is a function which can be called to create a functor.
# functor creation is defered so initial state (sampled in functorFunc)
# will be appropriate for the time the lerp is spawned
from direct.task import Task
from direct.showbase import LerpBlendHelpers
from direct.task.TaskManagerGlobal import taskMgr
# upon death remove the functorFunc
def lerpUponDeath(task):
# Try to break circular references
try:
del task.functorFunc
except:
pass
try:
del task.lerp
except:
pass
# make the task function
def lerpTaskFunc(task):
from pandac.Lerp import Lerp
from pandac.ClockObject import ClockObject
from direct.task.Task import Task, cont, done
if task.init == 1:
# make the lerp
functor = task.functorFunc()
task.lerp = Lerp(functor, task.duration, task.blendType)
task.init = 0
dt = globalClock.getDt()
task.lerp.setStepSize(dt)
task.lerp.step()
if (task.lerp.isDone()):
# Reset the init flag, in case the task gets re-used
task.init = 1
return(done)
else:
return(cont)
# make the lerp task
lerpTask = Task.Task(lerpTaskFunc)
lerpTask.init = 1
lerpTask.functorFunc = functorFunc
lerpTask.duration = duration
lerpTask.blendType = LerpBlendHelpers.getBlend(blendType)
lerpTask.setUponDeath(lerpUponDeath)
if (taskName == None):
# don't spawn a task, return one instead
return lerpTask
else:
# spawn the lerp task
taskMgr.add(lerpTask, taskName)
return lerpTask
def spawnMouseRotateTask(self):
taskMgr.remove('manipulateCamera')
if self.perspCollPlane:
iRay = SelectionRay(base.direct.camera)
iRay.collider.setFromLens(base.direct.camNode, 0.0, 0.0)
iRay.collideWithBitMask(1)
if base.direct.camera.getPos().getZ() >= 0:
iRay.ct.traverse(self.perspCollPlane)
else:
iRay.ct.traverse(self.perspCollPlane2)
if iRay.getNumEntries() > 0:
entry = iRay.getEntry(0)
hitPt = entry.getSurfacePoint(entry.getFromNodePath())
np = NodePath('temp')
np.setPos(base.direct.camera, hitPt)
self.coaMarkerPos = np.getPos()
np.remove()
self.coaMarker.setPos(self.coaMarkerPos)
iRay.collisionNodePath.removeNode()
del iRay
self.camManipRef.setPos(self.coaMarkerPos)
self.camManipRef.setHpr(base.direct.camera, ZERO_POINT)
t = Task.Task(self.mouseRotateTask)
if abs(base.direct.dr.mouseX) > 0.90000000000000002:
t.constrainedDir = 'y'
else:
t.constrainedDir = 'x'
taskMgr.add(t, 'manipulateCamera')
def manipulationStart(self, modifiers):
# Start out in select mode
self.mode = 'select'
# Check for a widget hit point
entry = SEditor.iRay.pickWidget()
# Did we hit a widget?
if entry:
# Yes!
self.hitPt.assign(entry.getSurfacePoint(entry.getFromNodePath()))
self.hitPtDist = Vec3(self.hitPt).length()
# Constraint determined by nodes name
self.constraint = entry.getIntoNodePath().getName()
else:
# Nope, off the widget, no constraint
self.constraint = None
# Check to see if we are moving the object
# We are moving the object if we either wait long enough
taskMgr.doMethodLater(MANIPULATION_MOVE_DELAY, self.switchToMoveMode,
'manip-move-wait')
# Or we move far enough
self.moveDir = None
watchMouseTask = Task.Task(self.watchMouseTask)
watchMouseTask.initX = SEditor.dr.mouseX
watchMouseTask.initY = SEditor.dr.mouseY
taskMgr.add(watchMouseTask, 'manip-watch-mouse')
def __lerp(self, functorFunc, duration, blendType, taskName=None):
from direct.task import Task
from direct.showbase import LerpBlendHelpers
from direct.task.TaskManagerGlobal import taskMgr
def lerpTaskFunc(task):
from pandac.PandaModules import Lerp
from pandac.PandaModules import ClockObject
from direct.task.Task import Task, cont, done
if task.init == 1:
functor = task.functorFunc()
task.lerp = Lerp(functor, task.duration, task.blendType)
task.init = 0
dt = globalClock.getDt()
task.lerp.setStepSize(dt)
task.lerp.step()
if task.lerp.isDone():
task.init = 1
return done
else:
return cont
lerpTask = Task.Task(lerpTaskFunc)
lerpTask.init = 1
lerpTask.functorFunc = functorFunc
lerpTask.duration = duration
lerpTask.blendType = LerpBlendHelpers.getBlend(blendType)
if taskName == None:
return lerpTask
else:
taskMgr.add(lerpTask, taskName)
return lerpTask
return
def fadeIn(self, t=0.5, block=0):
"""
Play a fade in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the color
from black to transparent. When the color lerp is finished, it
parents the fade polygon to hidden. If block is set, return the
sequence instead of spawning it.
"""
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, FADE_SORT_INDEX)
if (t == 0):
# Fade in immediately with no lerp
self.fade.reparentTo(hidden)
else:
# Create a sequence that lerps the color out, then
# parents the fade to hidden
r = self.fadeColor[0]
g = self.fadeColor[1]
b = self.fadeColor[2]
task = Task.sequence(
self.fade.lerpColor(r,g,b,1,
r,g,b,0,
t),
Task.Task(self.__fadeInLerpDone))
# Spawn the sequence
if not block:
taskMgr.add(task, self.fadeTaskName)
else:
return task
def __init__(self, host="localhost", port=5001, name="client"):
self.name = name
self.cManager = QueuedConnectionManager()
self.cReader = QueuedConnectionReader(self.cManager, 0)
self.cWriter = ConnectionWriter(self.cManager, 0)
self.readerCallbacks = []
taskMgr = Task.TaskManager()
# how long until we give up trying to reach the server?
timeout_in_miliseconds = 3000 # 3 seconds
self.myConnection = self.cManager.openTCPClientConnection(
host, port, timeout_in_miliseconds)
if not self.myConnection:
print("{}: Failed to connect to server!".format(self.name))
return
self.cReader.addConnection(
self.myConnection) # receive messages from server
taskMgr.add(self.tskReaderPolling, "Poll the connection reader", -40)
print("{}: Successfully connected to server {} at {}!".format(
self.name, port, host))
def showHpText(self, number, bonus=0, scale=1):
if self.HpTextEnabled and not (self.ghostMode):
if number != 0:
if self.hpText:
self.hideHpText()
self.HpTextGenerator.setFont(OTPGlobals.getSignFont())
if number < 0:
self.HpTextGenerator.setText(str(number))
else:
self.HpTextGenerator.setText("+" + str(number))
self.HpTextGenerator.clearShadow()
self.HpTextGenerator.setAlign(TextNode.ACenter)
if bonus == 1:
r = 1.0
g = 1.0
b = 0
a = 1
elif bonus == 2:
r = 1.0
g = 0.5
b = 0
a = 1
elif number < 0:
r = 0.90000000000000002
g = 0
b = 0
a = 1
else:
r = 0
g = 0.90000000000000002
b = 0
a = 1
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
self.hpText = self.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
self.hpText.setBillboardPointEye()
self.hpText.setBin("fixed", 100)
self.hpText.setPos(0, 0, self.height / 2)
seq = Task.sequence(
self.hpText.lerpPos(Point3(0, 0, self.height + 1.5), 1.0, blendType="easeOut"),
Task.pause(0.84999999999999998),
self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0), 0.10000000000000001),
Task.Task(self.hideHpTextTask),
)
taskMgr.add(seq, self.uniqueName("hpText"))
def __init__(self):
self.loadDefaultConfig()
self.loadLocalConfig()
if ConfigVariableBool("want-pstats", False):
PStatClient.connect()
# Set up some global objects
self.globalClock = ClockObject.getGlobalClock()
# We will manually manage the clock
self.globalClock.setMode(ClockObject.MSlave)
builtins.globalClock = self.globalClock
self.vfs = VirtualFileSystem.getGlobalPtr()
# For tasks that run every application frame
self.taskMgr = TaskManagerGlobal.taskMgr
builtins.taskMgr = self.taskMgr
# For tasks that run every simulation tick
self.simTaskMgr = Task.TaskManager()
self.simTaskMgr.mgr = AsyncTaskManager("sim")
builtins.simTaskmgr = self.simTaskMgr
self.eventMgr = EventManagerGlobal.eventMgr
builtins.eventMgr = self.eventMgr
self.messenger = MessengerGlobal.messenger
builtins.messenger = self.messenger
self.loader = Loader(self)
builtins.loader = self.loader
builtins.base = self
# What is the current frame number?
self.frameCount = 0
# Time at beginning of current frame
self.frameTime = self.globalClock.getRealTime()
# How long did the last frame take.
self.deltaTime = 0
#
# Variables pertaining to simulation ticks.
#
self.prevRemainder = 0
self.remainder = 0
# What is the current overall simulation tick?
self.tickCount = 0
# How many ticks are we going to run this frame?
self.totalTicksThisFrame = 0
# How many ticks have we run so far this frame?
self.currentTicksThisFrame = 0
# What tick are we currently on this frame?
self.currentFrameTick = 0
# How many simulations ticks are we running per-second?
self.ticksPerSec = 60
self.intervalPerTick = 1.0 / self.ticksPerSec
def spawnXZTranslateOrHPanYZoom(self):
# Kill any existing tasks
taskMgr.remove('manipulateCamera')
# Spawn the new task
t = Task.Task(self.XZTranslateOrHPanYZoomTask)
# For HPanYZoom
t.zoomSF = Vec3(self.coaMarker.getPos(base.direct.camera)).length()
taskMgr.add(t, 'manipulateCamera')
def spawnTask(self, name=None, callback=None, extraArgs=[]):
if not name:
name = str(self.getUrl())
from direct.task import Task
task = Task.Task(self.doTask)
task.callback = callback
task.callbackArgs = extraArgs
return taskMgr.add(task, name)
def __spawnTask(self):
# Spawn task
from direct.task import Task
self.__removeTask()
taskName = self.getName() + '-play'
task = Task.Task(self.__playTask)
task.interval = self
taskMgr.add(task, taskName)
def irisOutTask(self, task, time=0.5, noIris=1):
"""
As a sequence: iris out, execute the given task, then do a noIris
if requested
"""
if noIris:
def noIrisTask(task):
task.noIris()
return Task.done
nit = Task.Task(noIrisTask)
nit.noIris = self.noIris
seq = Task.sequence(self.irisOut(time, block=1), task, nit)
else:
seq = Task.sequence(self.irisOut(time, block=1), task)
# do it
taskMgr.add(seq, 'irisOutTaskSeq')
def fadeOutTask(self, task, time=0.3, noFade=1):
"""
As a sequence: Fade out, execute the given task, then do a noFade
if requested
"""
if noFade:
def noFadeTask(task):
task.noFade()
return Task.done
nft = Task.Task(noFadeTask)
nft.noFade = self.noFade
seq = Task.sequence(self.fadeOut(time, block=1), task, nft)
else:
seq = Task.sequence(self.fadeOut(time, block=1), task)
# do it
taskMgr.add(seq, 'fadeOutTaskSeq')
def spawnUpdateObjectUITask(self):
if self.currNodePath is None:
return
taskMgr.remove('_le_updateObjectUITask')
t = Task.Task(self.updateObjectUITask)
t.np = self.currNodePath
taskMgr.add(t, '_le_updateObjectUITask')
def __decButtonDown(self, event):
assert self.notify.debugStateCall(self)
task = Task.Task(self.__scrollByTask)
task.delayTime = (1.0 / self.scrollSpeed)
task.prevTime = 0.0
task.delta = -1
self.scrollBy(task.delta)
taskMgr.add(task, self.taskName("scroll"))
def startSleepSwimTest(self):
taskName = self.taskName('sleepSwimTest')
taskMgr.remove(taskName)
task = Task.Task(self.sleepSwimTest)
self.lastMoved = globalClock.getFrameTime()
self.lastState = None
self.lastAction = None
self.sleepSwimTest(task)
taskMgr.add(self.sleepSwimTest, taskName, 35)
def spawnMouseRollTask(self):
taskMgr.remove('manipulateCamera')
self.camManipRef.setPos(self.coaMarkerPos)
self.camManipRef.setHpr(base.direct.camera, ZERO_POINT)
t = Task.Task(self.mouseRollTask)
t.coaCenter = getScreenXY(self.coaMarker)
t.lastAngle = getCrankAngle(t.coaCenter)
t.wrt = base.direct.camera.getTransform(self.camManipRef)
taskMgr.add(t, 'manipulateCamera')
def startTrackAnimToSpeed(self):
taskName = self.taskName('trackAnimToSpeed')
taskMgr.remove(taskName)
task = Task.Task(self.trackAnimToSpeed)
self.lastMoved = globalClock.getFrameTime()
self.lastState = None
self.lastAction = None
self.trackAnimToSpeed(task)
taskMgr.add(self.trackAnimToSpeed, taskName, 35)
def __startManipulateCamera(self, func=None, task=None, ival=None):
self.__stopManipulateCamera()
if func:
assert (task is None)
task = Task.Task(func)
if task:
self.manipulateCameraTask = taskMgr.add(task, 'manipulateCamera')
if ival:
ival.start()
self.manipulateCameraInterval = ival
def __fireCannonTask(self, task):
launchTime = 0.0
toonId = task.toonId
cannon = task.cannon
toon = cannon.getToonInside()
self.notify.debug(str(self.doId) + ' FIRING CANNON FOR TOON ' + str(toonId))
if not cannon.isToonInside():
return Task.done
if self.isLocalToonId(toonId):
self.inWater = 0
startPos, startHpr, startVel, trajectory = self.__calcFlightResults(cannon, toonId, launchTime)
self.notify.debug('start position: ' + str(startPos))
self.notify.debug('start velocity: ' + str(startVel))
self.notify.debug('time of launch: ' + str(launchTime))
cannon.removeToonReadyToFire()
shootTask = Task.Task(self.__shootTask, self.taskNameShoot)
shootTask.info = {'toonId': toonId,
'cannon': cannon}
if self.isLocalToonId(toonId):
self.flyingToonOffsetRotation = 0
self.flyingToonOffsetAngle = 0
self.flyingToonOffsetX = 0
self.flyingToonOffsetY = 0
self.hitCloud = 0
self.initialFlyVel = INITIAL_VELOCITY
self.camNode = NodePath(self.uniqueName('flyingCamera'))
self.camNode.setScale(0.5)
self.camNode.setPos(self.localFlyingToon.getPos())
self.camNode.setHpr(self.localFlyingToon.getHpr())
self.camNode.reparentTo(render)
self.lastStartVel = startVel
place = base.cr.playGame.getPlace()
place.fsm.request('activity')
toon.dropShadow.hide()
self.localFlyingDropShadow = self.shadowNode.copyTo(hidden)
vel = startVel
toon.lookAt(toon.getPos() + Vec3(vel[0], vel[1], vel[2]))
toon.setP(localAvatar, -90)
hpr = toon.getHpr()
toon.d_setPosHpr(startPos[0], startPos[1], startPos[2], hpr[0], hpr[1], hpr[2])
self.localFlyingToon.wrtReparentTo(render)
info = {}
info['toonId'] = toonId
info['trajectory'] = trajectory
info['launchTime'] = launchTime
info['toon'] = self.localFlyingToon
info['hRot'] = cannon.getRotation()
base.camera.wrtReparentTo(self.localFlyingToon)
flyTask = Task.Task(self.__localFlyTask, self.taskNameFly)
flyTask.info = info
seqTask = Task.sequence(shootTask, flyTask)
self.__startCollisionHandler()
self.notify.debug('Disable standard local toon controls.')
base.localAvatar.disableAvatarControls()
frameTime = globalClock.getFrameTime()
netLaunchTime = globalClockDelta.localToNetworkTime(launchTime + frameTime, bits=31)
self.sendUpdate('setToonTrajectoryAi', [netLaunchTime,
startPos[0],
startPos[1],
startPos[2],
startHpr[0],
startHpr[1],
startHpr[2],
startVel[0],
startVel[1],
startVel[2]])
else:
seqTask = shootTask
taskMgr.add(seqTask, self.taskName('flyingToon') + '-' + str(toonId))
toon.startSmooth()
return Task.done
def irisInTask(self, task, time=0.5):
"""
As a sequence: iris in, execute the given task
"""
seq = Task.sequence(self.irisIn(time, block=1), task)
taskMgr.add(seq, 'irisInTaskSeq')
def fadeInTask(self, task, time=0.5):
"""
As a sequence: Fade in, execute the given task
"""
seq = Task.sequence(self.fadeIn(time, block=1), task)
taskMgr.add(seq, 'fadeInTaskSeq')
def showHpText(self, number, bonus = 0, scale = 1, attackTrack = -1):
if self.HpTextEnabled and not self.ghostMode:
if number != 0:
if self.hpText:
self.hideHpText()
self.HpTextGenerator.setFont(OTPGlobals.getSignFont())
if number < 0:
self.HpTextGenerator.setText(str(number))
if base.cr.newsManager.isHolidayRunning(ToontownGlobals.SILLY_SURGE_HOLIDAY):
self.sillySurgeText = True
absNum = abs(number)
if absNum > 0 and absNum <= 10:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[1])
elif absNum > 10 and absNum <= 20:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[2])
elif absNum > 20 and absNum <= 30:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[3])
elif absNum > 30 and absNum <= 40:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[4])
elif absNum > 40 and absNum <= 50:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[5])
elif absNum > 50 and absNum <= 60:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[6])
elif absNum > 60 and absNum <= 70:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[7])
elif absNum > 70 and absNum <= 80:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[8])
elif absNum > 80 and absNum <= 90:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[9])
elif absNum > 90 and absNum <= 100:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[10])
elif absNum > 100 and absNum <= 110:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[11])
else:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.SillySurgeTerms[12])
if self.interactivePropTrackBonus > -1 and self.interactivePropTrackBonus == attackTrack:
self.sillySurgeText = True
if attackTrack in TTLocalizer.InteractivePropTrackBonusTerms:
self.HpTextGenerator.setText(str(number) + '\n' + TTLocalizer.InteractivePropTrackBonusTerms[attackTrack])
else:
self.HpTextGenerator.setText('+' + str(number))
self.HpTextGenerator.clearShadow()
self.HpTextGenerator.setAlign(TextNode.ACenter)
if bonus == 1:
r = 1.0
g = 1.0
b = 0
a = 1
elif bonus == 2:
r = 1.0
g = 0.5
b = 0
a = 1
elif number < 0:
r = 0.9
g = 0
b = 0
a = 1
if self.interactivePropTrackBonus > -1 and self.interactivePropTrackBonus == attackTrack:
r = 0
g = 0
b = 1
a = 1
else:
r = 0
g = 0.9
b = 0
a = 1
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
self.hpText = self.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
self.hpText.setBillboardPointEye()
self.hpText.setBin('fixed', 100)
if self.sillySurgeText:
self.nametag3d.setDepthTest(0)
self.nametag3d.setBin('fixed', 99)
self.hpText.setPos(0, 0, self.height / 2)
seq = Task.sequence(self.hpText.lerpPos(Point3(0, 0, self.height + 1.5), 1.0, blendType='easeOut'), Task.pause(0.85), self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0), 0.1), Task.Task(self.hideHpTextTask))
taskMgr.add(seq, self.uniqueName('hpText'))
