def move(self, dt = -1, profile = 0):
if Mover.Profile and not profile:
def func(doMove = self.move):
for i in xrange(10000):
doMove(dt, profile=1)
__builtin__.func = func
PythonUtil.startProfile(cmd='func()', filename='profile', sorts=['cumulative'], callInfo=0)
del __builtin__.func
return
if Mover.Pstats:
self.pscCpp.start()
CMover.processCImpulses(self, dt)
if Mover.Pstats:
self.pscCpp.stop()
self.pscPy.start()
for impulse in self.impulses.values():
impulse._process(self.getDt())
if Mover.Pstats:
self.pscPy.stop()
self.pscInt.start()
CMover.integrate(self)
if Mover.Pstats:
self.pscInt.stop()
def test_flywheel():
f = PythonUtil.flywheel(['a','b','c','d'], countList=[11,20,3,4])
obj2count = {}
for obj in f:
obj2count.setdefault(obj, 0)
obj2count[obj] += 1
assert obj2count['a'] == 11
assert obj2count['b'] == 20
assert obj2count['c'] == 3
assert obj2count['d'] == 4
f = PythonUtil.flywheel([1,2,3,4], countFunc=lambda x: x*2)
obj2count = {}
for obj in f:
obj2count.setdefault(obj, 0)
obj2count[obj] += 1
assert obj2count[1] == 2
assert obj2count[2] == 4
assert obj2count[3] == 6
assert obj2count[4] == 8
f = PythonUtil.flywheel([1,2,3,4], countFunc=lambda x: x, scale = 3)
obj2count = {}
for obj in f:
obj2count.setdefault(obj, 0)
obj2count[obj] += 1
assert obj2count[1] == 1 * 3
assert obj2count[2] == 2 * 3
assert obj2count[3] == 3 * 3
assert obj2count[4] == 4 * 3
def unlockStateChangeMsg(self):
if self.stateChangeMsgLocks <= 0:
print PythonUtil.lineTag() + ": someone unlocked too many times"
return
self.stateChangeMsgLocks -= 1
if self.stateChangeMsgLocks == 0 and self.stateHasChanged:
messenger.send(self.EmoteEnableStateChanged)
self.stateHasChanged = 0
def __init__(self):
self.config = getConfigShowbase()
__builtins__["__dev__"] = self.config.GetBool("want-dev", 0)
if self.config.GetBool("use-vfs", 1):
vfs = VirtualFileSystem.getGlobalPtr()
else:
vfs = None
self.wantTk = self.config.GetBool("want-tk", 0)
self.AISleep = self.config.GetFloat("ai-sleep", 0.04)
self.AIRunningNetYield = self.config.GetBool("ai-running-net-yield", 0)
self.AIForceSleep = self.config.GetBool("ai-force-sleep", 0)
self.eventMgr = eventMgr
self.messenger = messenger
self.bboard = bulletinBoard
self.taskMgr = taskMgr
Task.TaskManager.taskTimerVerbose = self.config.GetBool("task-timer-verbose", 0)
Task.TaskManager.extendedExceptions = self.config.GetBool("extended-exceptions", 0)
self.sfxManagerList = None
self.musicManager = None
self.jobMgr = jobMgr
self.hidden = NodePath("hidden")
self.graphicsEngine = GraphicsEngine()
globalClock = ClockObject.getGlobalClock()
self.trueClock = TrueClock.getGlobalPtr()
globalClock.setRealTime(self.trueClock.getShortTime())
globalClock.setAverageFrameRateInterval(30.0)
globalClock.tick()
taskMgr.globalClock = globalClock
__builtins__["ostream"] = Notify.out()
__builtins__["globalClock"] = globalClock
__builtins__["vfs"] = vfs
__builtins__["hidden"] = self.hidden
PythonUtil.recordFunctorCreationStacks()
self.wantStats = self.config.GetBool("want-pstats", 0)
Task.TaskManager.pStatsTasks = self.config.GetBool("pstats-tasks", 0)
taskMgr.resumeFunc = PStatClient.resumeAfterPause
wantFakeTextures = self.config.GetBool("want-fake-textures-ai", 1)
if wantFakeTextures:
loadPrcFileData("aibase", "textures-header-only 1")
self.wantPets = self.config.GetBool("want-pets", 1)
if self.wantPets:
from toontown.pets import PetConstants
self.petMoodTimescale = self.config.GetFloat("pet-mood-timescale", 1.0)
self.petMoodDriftPeriod = self.config.GetFloat("pet-mood-drift-period", PetConstants.MoodDriftPeriod)
self.petThinkPeriod = self.config.GetFloat("pet-think-period", PetConstants.ThinkPeriod)
self.petMovePeriod = self.config.GetFloat("pet-move-period", PetConstants.MovePeriod)
self.petPosBroadcastPeriod = self.config.GetFloat(
"pet-pos-broadcast-period", PetConstants.PosBroadcastPeriod
)
self.wantBingo = self.config.GetBool("want-fish-bingo", 1)
self.wantKarts = self.config.GetBool("want-karts", 1)
self.backups = BackupManager.BackupManager(
filepath=self.config.GetString("backups-filepath", "dependencies/backups/"),
extension=self.config.GetString("backups-extension", ".json"),
)
self.createStats()
self.restart()
def __startWalk(self):
self.__stopWalk()
if self.target:
now = globalClock.getFrameTime()
availableTime = self.arrivalTime - now
if availableTime > 0:
origH = self.getH()
h = PythonUtil.fitDestAngle2Src(origH, self.targetH)
delta = abs(h - origH)
turnTime = delta / (self.velocity * 5)
dist = Vec3(self.target - self.getPos()).length()
walkTime = dist / self.velocity
denom = turnTime + walkTime
if denom != 0:
timeCompress = availableTime / denom
self.walkTrack = Sequence(
self.hprInterval(
turnTime *
timeCompress,
VBase3(
h,
0,
0)),
self.posInterval(
walkTime *
timeCompress,
self.target))
self.walkTrack.start()
else:
self.setPos(self.target)
self.setH(self.targetH)
def enterBoarding(self, nodePath, side):
camera.wrtReparentTo(nodePath)
heading = PythonUtil.fitDestAngle2Src(camera.getH(nodePath), 90 * side)
self.cameraBoardTrack = LerpPosHprInterval(
camera, 1.5, Point3(14.4072 * side, 0, 3.8666999999999998), Point3(heading, -15, 0)
)
self.cameraBoardTrack.start()
def resume(self, currentFloor = 0, topFloor = 0):
if len(self.suits) == 0:
self.d_setMembers()
self.suitsKilledPerFloor.append(self.suitsKilledThisBattle)
if topFloor == 0:
self.b_setState('Reward')
else:
for (floorNum, cogsThisFloor) in PythonUtil.enumerate(self.suitsKilledPerFloor):
for toonId in self.activeToons:
toon = self.getToon(toonId)
if toon:
(recovered, notRecovered) = self.air.questManager.recoverItems(toon, cogsThisFloor, self.zoneId)
self.toonItems[toonId][0].extend(recovered)
self.toonItems[toonId][1].extend(notRecovered)
meritArray = self.air.promotionMgr.recoverMerits(toon, cogsThisFloor, self.zoneId, getCreditMultiplier(floorNum))
if toonId in self.helpfulToons:
self.toonMerits[toonId] = addListsByValue(self.toonMerits[toonId], meritArray)
else:
self.notify.debug('toon %d not helpful, skipping merits' % toonId)
self.d_setBattleExperience()
self.b_setState('BuildingReward')
elif self.resumeNeedUpdate == 1:
self.d_setMembers()
if len(self.resumeDeadSuits) > 0 or self.resumeLastActiveSuitDied == 0 or len(self.resumeDeadToons) > 0:
self.needAdjust = 1
self.setState('WaitForJoin')
self.resumeNeedUpdate = 0
self.resumeDeadToons = []
self.resumeDeadSuits = []
self.resumeLastActiveSuitDied = 0
def getIntroTrack(self):
self.__cameraTask(None)
origCamParent = camera.getParent()
origCamPos = camera.getPos()
origCamHpr = camera.getHpr()
iCamParent = base.localAvatar.attachNewNode('iCamParent')
iCamParent.setH(180)
camera.reparentTo(iCamParent)
toonHeight = base.localAvatar.getHeight()
camera.setPos(0, -15, toonHeight * 3)
camera.lookAt(0, 0, toonHeight / 2.0)
iCamParent.wrtReparentTo(origCamParent)
waitDur = 5.0
lerpDur = 4.5
lerpTrack = Parallel()
startHpr = iCamParent.getHpr()
startHpr.setX(PythonUtil.reduceAngle(startHpr[0]))
lerpTrack.append(LerpPosHprInterval(iCamParent, lerpDur, pos=Point3(0, 0, 0), hpr=Point3(0, 0, 0), startHpr=startHpr, name=self.uniqueName('introLerpParent')))
lerpTrack.append(LerpPosHprInterval(camera, lerpDur, pos=origCamPos, hpr=origCamHpr, blendType='easeInOut', name=self.uniqueName('introLerpCameraPos')))
base.localAvatar.startLookAround()
def cleanup(origCamParent = origCamParent, origCamPos = origCamPos, origCamHpr = origCamHpr, iCamParent = iCamParent):
camera.reparentTo(origCamParent)
camera.setPos(origCamPos)
camera.setHpr(origCamHpr)
iCamParent.removeNode()
del iCamParent
base.localAvatar.stopLookAround()
return Sequence(Wait(waitDur),
lerpTrack,
Func(cleanup))
def generateToonMoveTrack(self):
hpr = self.movieNode.getHpr(render)
heading = PythonUtil.fitDestAngle2Src(self.av.getH(render), hpr[0])
hpr.setX(heading)
self.av.setAnimState('run', 1.0)
toonTrack = Sequence(Wait(0.5), Parallel(LerpPosInterval(self.av, 1.0, Point3(self.movieNode.getX(self.avParent), self.movieNode.getY(self.avParent), 0)), LerpHprInterval(self.av, 1.0, hpr=hpr, other=render)), Func(self.av.loop, 'neutral'))
return toonTrack
def serverTime(self, context, timestamp, timeOfDay):
end = globalClock.getRealTime()
aiTimeSkew = timeOfDay - self.cr.getServerTimeOfDay()
if context != self.thisContext:
self.notify.info('Ignoring TimeManager response for old context %d' % context)
return
elapsed = end - self.start
self.attemptCount += 1
self.notify.info('Clock sync roundtrip took %0.3f ms' % (elapsed * 1000.0))
self.notify.info('AI time delta is %s from server delta' % PythonUtil.formatElapsedSeconds(aiTimeSkew))
average = (self.start + end) / 2.0 - self.extraSkew
uncertainty = (end - self.start) / 2.0 + abs(self.extraSkew)
globalClockDelta.resynchronize(average, timestamp, uncertainty)
self.notify.info('Local clock uncertainty +/- %.3f s' % globalClockDelta.getUncertainty())
if globalClockDelta.getUncertainty() > self.maxUncertainty:
if self.attemptCount < self.maxAttempts:
self.notify.info('Uncertainty is too high, trying again.')
self.start = globalClock.getRealTime()
self.sendUpdate('requestServerTime', [self.thisContext])
return
self.notify.info('Giving up on uncertainty requirement.')
if self.talkResult:
base.localAvatar.setChatAbsolute('latency %0.0f ms, sync \xc2\xb1%0.0f ms' % (elapsed * 1000.0, globalClockDelta.getUncertainty() * 1000.0), CFSpeech | CFTimeout)
self._gotFirstTimeSync = True
messenger.send('gotTimeSync')
def serverTime(self, context, timestamp, timeOfDay):
end = globalClock.getRealTime()
aiTimeSkew = timeOfDay - self.cr.getServerTimeOfDay()
if context != self.thisContext:
self.notify.info('Ignoring TimeManager response for old context %d' % context)
return
elapsed = end - self.start
self.attemptCount += 1
self.notify.info('Clock sync roundtrip took %0.3f ms' % (elapsed * 1000.0))
self.notify.info('AI time delta is %s from server delta' % PythonUtil.formatElapsedSeconds(aiTimeSkew))
average = (self.start + end) / 2.0
uncertainty = (end - self.start) / 2.0
globalClockDelta.resynchronize(average, timestamp, uncertainty)
self.notify.info('Local clock uncertainty +/- %.3f s' % globalClockDelta.getUncertainty())
if globalClockDelta.getUncertainty() > self.maxUncertainty:
if self.attemptCount < self.maxAttempts:
self.notify.info('Uncertainty is too high, trying again.')
self.start = globalClock.getRealTime()
self.sendUpdate('requestServerTime', [self.thisContext])
return
self.notify.info('Giving up on uncertainty requirement.')
self._gotFirstTimeSync = True
messenger.send('gotTimeSync')
toontownTimeManager = getattr(base.cr, 'toontownTimeManager', None)
if toontownTimeManager:
toontownTimeManager.updateLoginTimes(timeOfDay, int(time.time()), globalClock.getRealTime())
def rollBossToPoint(self, fromPos, fromHpr, toPos, toHpr, reverse):
vector = Vec3(toPos - fromPos)
distance = vector.length()
if toHpr == None:
mat = Mat3(0, 0, 0, 0, 0, 0, 0, 0, 0)
headsUp(mat, vector, CSDefault)
scale = VBase3(0, 0, 0)
shear = VBase3(0, 0, 0)
toHpr = VBase3(0, 0, 0)
decomposeMatrix(mat, scale, shear, toHpr, CSDefault)
if fromHpr:
newH = PythonUtil.fitDestAngle2Src(fromHpr[0], toHpr[0])
toHpr = VBase3(newH, 0, 0)
else:
fromHpr = toHpr
turnTime = abs(toHpr[0] - fromHpr[0]) / ToontownGlobals.BossCogTurnSpeed
if toHpr[0] < fromHpr[0]:
leftRate = ToontownGlobals.BossCogTreadSpeed
else:
leftRate = -ToontownGlobals.BossCogTreadSpeed
if reverse:
rollTreadRate = -ToontownGlobals.BossCogTreadSpeed
else:
rollTreadRate = ToontownGlobals.BossCogTreadSpeed
rollTime = distance / ToontownGlobals.BossCogRollSpeed
deltaPos = toPos - fromPos
track = Sequence(Func(self.setPos, fromPos), Func(self.headsUp, toPos), Parallel(self.hprInterval(turnTime, toHpr, fromHpr), self.rollLeftTreads(turnTime, leftRate), self.rollRightTreads(turnTime, -leftRate)), Parallel(LerpFunctionInterval(self.rollBoss, duration=rollTime, extraArgs=[fromPos, deltaPos]), self.rollLeftTreads(rollTime, rollTreadRate), self.rollRightTreads(rollTime, rollTreadRate)))
return (track, toHpr)
def debugStateCall(self, obj = None, fsmMemberName = 'fsm', secondaryFsm = 'secondaryFSM'):
if self.__debug:
state = ''
doId = ''
if obj is not None:
fsm = obj.__dict__.get(fsmMemberName)
if fsm is not None:
stateObj = fsm.getCurrentState()
if stateObj is not None:
state = stateObj.getName()
fsm = obj.__dict__.get(secondaryFsm)
if fsm is not None:
stateObj = fsm.getCurrentState()
if stateObj is not None:
state = '%s, %s' % (state, stateObj.getName())
if hasattr(obj, 'doId'):
doId = ' doId:%s' % (obj.doId,)
string = ':%s:%s [%-7s] id(%s)%s %s' % (self.getOnlyTime(),
self.__name,
state,
id(obj),
doId,
PythonUtil.traceParentCall())
self.__log(string)
self.__print(string)
return 1
def setMagicWord(self, word, avId, zoneId):
try:
self.doMagicWord(word, avId, zoneId)
except:
response = PythonUtil.describeException(backTrace=1)
self.notify.warning("Ignoring error in magic word:\n%s" % response)
self.setMagicWordResponse(response)
def generateToonMoveTrack(self, toon):
node = NodePath("tempNode")
displacement = Vec3(toon.getPos(render) - self.getPos(render))
displacement.setZ(0)
displacement.normalize()
movieDistance = self.movieNode.getDistance(self.rotateNode)
displacement *= movieDistance
node.reparentTo(render)
node.setPos(displacement + self.getPos(render))
node.lookAt(self)
heading = PythonUtil.fitDestAngle2Src(toon.getH(render), node.getH(render))
hpr = toon.getHpr(render)
hpr.setX(heading)
finalX = node.getX(render)
finalY = node.getY(render)
finalZ = node.getZ(render)
node.removeNode()
toonTrack = Sequence(
Parallel(
ActorInterval(toon, "walk", loop=True, duration=1),
Parallel(
LerpPosInterval(toon, 1.0, Point3(finalX, finalY, toon.getZ(render)), fluid=True, bakeInStart=False)
),
LerpHprInterval(toon, 1.0, hpr=hpr),
),
Func(toon.loop, "neutral"),
)
return toonTrack
def timerTask(task):
if task.time < task.timer:
self.timerLabel['text'] = `int(PythonUtil.bound(task.timer - task.time, 0, time) + 1.0)`
return Task.cont
else:
self.timerLabel['text'] = ''
return Task.done
def cleanUpEffect(self):
if self.wantTrail:
self.motion_trail.endTrail()
self.motion_trail2.endTrail()
taskMgr.remove(PythonUtil.uniqueName('homingMissileTask'))
EffectController.cleanUpEffect(self)
self.checkInEffect(self)
def enterBoarding(self, nodePath):
base.camera.wrtReparentTo(nodePath)
if self.reverseBoardingCamera:
heading = PythonUtil.fitDestAngle2Src(base.camera.getH(nodePath), 180)
self.cameraBoardTrack = LerpPosHprInterval(base.camera, 1.5, Point3(0, 18, 8), Point3(heading, -10, 0))
else:
self.cameraBoardTrack = LerpPosHprInterval(base.camera, 1.5, Point3(0, -16, 5.5), Point3(0, 0, 0))
self.cameraBoardTrack.start()
def setHeading(self, finalPos, initPos):
diffX = finalPos.getX() - initPos.getX()
angle = -90 * diffX / math.fabs(diffX)
startAngle = self.suit.getH()
startAngle = PythonUtil.fitSrcAngle2Dest(startAngle, angle)
dur = 0.1 * abs(startAngle - angle) / 90
self.suitTurnIval = LerpHprInterval(self.suit, dur, Point3(angle, 0, 0), startHpr=Point3(startAngle, 0, 0), name='SuitLerpHpr')
self.suitTurnIval.start()
def transitionSunAngle(self, newHpr, duration = 10.0, fade = 0, sunDirLast = None):
if sunDirLast != None:
sunVecCurrent = sunDirLast
else:
sunVecCurrent = Vec3(self.sunWheelHeading.getH(), self.sunWheelPitch.getP(), self.sunWheelRoll.getR())
aH = PythonUtil.fitSrcAngle2Dest(self.sunWheelHeading.getH(), newHpr[0])
aP = PythonUtil.fitSrcAngle2Dest(self.sunWheelPitch.getP(), newHpr[1])
aR = PythonUtil.fitSrcAngle2Dest(self.sunWheelRoll.getR(), newHpr[2])
self.sunWheelHeading.setH(aH)
self.sunWheelPitch.setP(aP)
self.sunWheelRoll.setR(aR)
sunVecFitted = Vec3(aH, aP, aR)
if fade:
ival = Sequence(LerpColorScaleInterval(self.sunTrack, duration * 0.29999999999999999, Vec4(1, 1, 1, 0)), LerpFunctionInterval(self.setSunTrueAngle, duration * 0.40000000000000002, fromData = sunVecFitted, toData = newHpr), LerpColorScaleInterval(self.sunTrack, duration * 0.29999999999999999, Vec4(1, 1, 1, 1)))
return ival
else:
return LerpFunctionInterval(self.setSunTrueAngle, duration, fromData = sunVecFitted, toData = newHpr)
def __hoverCallback(self, inside, hoodIndex, pos):
alpha = PythonUtil.choice(inside, 0.25, 1.0)
try:
clouds = self.clouds[hoodIndex]
except ValueError:
clouds = []
for cloud in clouds:
cloud.setColor((1, 1, 1, alpha))
def getPetInfoFromSeed(seed, safezoneId):
S = random.getstate()
random.seed(seed)
dnaArray = PetDNA.getRandomPetDNA(safezoneId)
gender = PetDNA.getGender(dnaArray)
nameString = TTLocalizer.getRandomPetName(gender=gender, seed=seed)
traitSeed = PythonUtil.randUint31()
random.setstate(S)
return (nameString, dnaArray, traitSeed)
def printTypeANameInfo(self, str):
sourceFilename, lineNumber, functionName = PythonUtil.stackEntryInfo(1)
self.notify.debug('========================================\n%s : %s : %s' % (sourceFilename, lineNumber, functionName))
self.notify.debug(str)
curPos = self.typeANameButton.getPos()
self.notify.debug('Pos = %.2f %.2f %.2f' % (curPos[0], curPos[1], curPos[2]))
parent = self.typeANameButton.getParent()
parentPos = parent.getPos()
self.notify.debug('Parent = %s' % parent)
self.notify.debug('ParentPos = %.2f %.2f %.2f' % (parentPos[0], parentPos[1], parentPos[2]))
def debugCall(self, debugString = ''):
if self.__debug:
message = str(debugString)
string = ':%s:%s "%s" %s' % (self.getOnlyTime(),
self.__name,
message,
PythonUtil.traceParentCall())
self.__log(string)
self.__print(string)
return 1
def moveCamera(self, seatIndex):
self.oldCameraPos = camera.getPos()
self.oldCameraHpr = camera.getHpr()
camera.wrtReparentTo(self.picnicTable)
heading = PythonUtil.fitDestAngle2Src(camera.getH(), 90)
if seatIndex < 3:
self.cameraBoardTrack = LerpPosHprInterval(camera, 2.0, Point3(0, 0, 17), Point3(0, -90, 0))
elif camera.getH() < 0:
self.cameraBoardTrack = LerpPosHprInterval(camera, 2.0, Point3(0, 0, 17), Point3(-180, -90, 0))
else:
self.cameraBoardTrack = LerpPosHprInterval(camera, 2.0, Point3(0, 0, 17), Point3(180, -90, 0))
self.cameraBoardTrack.start()
def __chooseTarget(self, extraDelay = 0):
direction = self.__chooseDirection()
if direction == None:
self.target = None
self.arrivalTime = None
self.b_destroyGoon()
return
heading, dist = direction
dist = min(dist, self.legLength)
targetH = PythonUtil.reduceAngle(self.getH() + heading)
origH = self.getH()
h = PythonUtil.fitDestAngle2Src(origH, targetH)
delta = abs(h - origH)
turnTime = delta / (self.velocity * 5)
walkTime = dist / self.velocity
self.setH(targetH)
self.target = self.boss.scene.getRelativePoint(self, Point3(0, dist, 0))
self.departureTime = globalClock.getFrameTime()
self.arrivalTime = self.departureTime + turnTime + walkTime + extraDelay
self.d_setTarget(self.target[0], self.target[1], h, globalClockDelta.localToNetworkTime(self.arrivalTime))
return
def takePhoneInterval(self, toon):
torso = TextEncoder.upper(toon.style.torso[0])
legs = TextEncoder.upper(toon.style.legs[0])
phoneOutAnim = "%s%s_phoneOut" % (torso, legs)
takePhoneAnim = "%s%s_takePhone" % (torso, legs)
phoneNeutralAnim = "%s%s_phoneNeutral" % (torso, legs)
self.toonScale = toon.getGeomNode().getChild(0).getScale(self.getParent())
walkTime = 1.0
scaleTime = 1.0
origScale = self.getScale()
origToonPos = toon.getPos()
origToonHpr = toon.getHpr()
self.origToonHpr = origToonHpr
self.setScale(self.toonScale)
toon.setPosHpr(self, 0, -4.5, 0, 0, 0, 0)
destToonPos = toon.getPos()
destToonHpr = toon.getHpr()
destToonHpr = VBase3(
PythonUtil.fitSrcAngle2Dest(destToonHpr[0], origToonHpr[0]), destToonHpr[1], destToonHpr[2]
)
self.setScale(origScale)
toon.setPos(origToonPos)
toon.setHpr(origToonHpr)
walkToPhone = Sequence(
Func(toon.stopSmooth),
Func(toon.loop, "walk"),
Func(base.playSfx, base.localAvatar.soundWalk),
toon.posHprInterval(walkTime, destToonPos, destToonHpr, blendType="easeInOut"),
Func(toon.loop, "neutral"),
Func(toon.startSmooth),
)
interval = Sequence(
Parallel(
walkToPhone,
ActorInterval(self.model, phoneOutAnim),
self.scaleInterval(scaleTime, self.toonScale, blendType="easeInOut"),
),
Parallel(
ActorInterval(self.model, takePhoneAnim),
ActorInterval(toon, "takePhone"),
Sequence(
Wait(0.625),
Func(base.playSfx, self.pickUpSfx),
Func(self.__receiverToHand, toon),
Wait(1),
Func(base.playSfx, self.handleSfx),
),
),
Func(self.model.loop, phoneNeutralAnim),
Func(toon.loop, "phoneNeutral"),
Func(base.playSfx, self.ringSfx),
)
return interval
def getJumpHpr(av = av, node = self.golfKart):
hpr = Point3(0, 0, 0)
if hasattr(self, 'golfKart') and self.golfKart:
hpr = self.golfKart.getHpr(av.getParent())
if seatIndex < 2:
hpr.setX(hpr.getX() + 180)
else:
hpr.setX(hpr.getX())
angle = PythonUtil.fitDestAngle2Src(av.getH(), hpr.getX())
hpr.setX(angle)
else:
self.notify.warning('getJumpHpr invalid golfKart, returning (0,0,0)')
return hpr
def getToonPullingLeverInterval(self, toon):
walkTime = 0.2
reach = ActorInterval(toon, 'leverReach', playRate=2.0)
pull = ActorInterval(toon, 'leverPull', startFrame=6)
origPos = toon.getPos(render)
origHpr = toon.getHpr(render)
newPos = self.lever.getPos(render)
newHpr = self.lever.getHpr(render)
origHpr.setX(PythonUtil.fitSrcAngle2Dest(origHpr[0], newHpr[0]))
toon.setPosHpr(origPos, origHpr)
reachAndPull = Sequence(ActorInterval(toon, 'walk', loop=True, duration=walkTime - reach.getDuration()), reach, pull)
leverSeq = Sequence(Wait(walkTime + reach.getDuration() - 0.1), self.stick.hprInterval(0.55, Point3(0.0, 25.0, 0.0), Point3(0.0, 0.0, 0.0)), Wait(0.3), self.stick.hprInterval(0.4, Point3(0.0, 0.0, 0.0), Point3(0.0, 25.0, 0.0)))
returnSeq = Sequence(Parallel(toon.posInterval(walkTime, newPos, origPos), toon.hprInterval(walkTime, newHpr, origHpr), leverSeq, reachAndPull))
return returnSeq
def process(self, invoker, target, incantation):
self.currentInvoker = invoker
self.currentTarget = target
word, args = (incantation.split(' ', 1) + [''])[:2]
try:
return self.doWord(word, args)
except MagicError as e:
return (e.message, True)
except Exception:
return (PythonUtil.describeException(backTrace=1), True)
finally:
self.currentInvoker = None
self.currentTarget = None
from toontown.fishing.FishPhoto import DirectRegion
from toontown.shtiker.ShtikerPage import ShtikerPage
from toontown.toonbase import ToontownGlobals, TTLocalizer
from .FishPage import FishingTrophy
from toontown.golf import GolfGlobals
##########################################################################
# Python Import Modules
##########################################################################
if (__debug__):
import pdb
##########################################################################
# Global Variables and Enumerations
##########################################################################
PageMode = PythonUtil.Enum("Records, Trophy")
class GolfPage(ShtikerPage):
"""
Purpose: The GolfPage class provides the basic functionality for
switching between the different pages like records, and trophies.
Note: The GolfPage is a singleton object because only one instance of
the page should exist at a time.
"""
######################################################################
# Class variables
######################################################################
#__metaclass__ = PythonUtil.Singleton
class Pet(Avatar.Avatar):
notify = DirectNotifyGlobal.directNotify.newCategory('Pet')
SerialNum = 0
Interactions = PythonUtil.Enum('SCRATCH, BEG, EAT, NEUTRAL')
InteractAnims = {Interactions.SCRATCH: ('toPet', 'pet', 'fromPet'),
Interactions.BEG: ('toBeg', 'beg', 'fromBeg'),
Interactions.EAT: ('eat', 'swallow', 'neutral'),
Interactions.NEUTRAL: 'neutral'}
def __init__(self, forGui = 0):
Avatar.Avatar.__init__(self)
self.serialNum = Pet.SerialNum
Pet.SerialNum += 1
self.lockedDown = 0
self.setPickable(1)
self.setPlayerType(NametagGroup.CCNonPlayer)
self.animFSM = ClassicFSM('petAnimFSM', [State('off', self.enterOff, self.exitOff),
State('neutral', self.enterNeutral, self.exitNeutral),
State('neutralHappy', self.enterNeutralHappy, self.exitNeutralHappy),
State('neutralSad', self.enterNeutralSad, self.exitNeutralSad),
State('run', self.enterRun, self.exitRun),
State('swim', self.enterSwim, self.exitSwim),
State('teleportIn', self.enterTeleportIn, self.exitTeleportOut),
State('teleportOut', self.enterTeleportOut, self.exitTeleportOut),
State('walk', self.enterWalk, self.exitWalk),
State('walkHappy', self.enterWalkHappy, self.exitWalkHappy),
State('walkSad', self.enterWalkSad, self.exitWalkSad)], 'off', 'off')
self.animFSM.enterInitialState()
self.forGui = forGui
self.moodModel = None
self.__blinkName = 'petblink-' + str(self.this)
self.track = None
self.soundBackflip = None
self.soundRollover = None
self.soundPlaydead = None
self.soundTeleportIn = None
self.soundTeleportOut = None
self.teleportHole = None
return
def isPet(self):
return True
def stopAnimations(self):
if self.track:
self.track.pause()
self.stopBlink()
self.animFSM.request('off')
def delete(self):
self.stopAnimations()
self.track = None
self.soundBackflip = None
self.soundRollover = None
self.soundPlaydead = None
self.soundTeleportIn = None
self.soundTeleportOut = None
if self.teleportHole:
self.teleportHole.cleanup()
self.teleportHole = None
self.eyesOpenTexture = None
self.eyesClosedTexture = None
self.animFSM = None
self.eyes = None
self.rightPupil = None
self.rightHighlight = None
self.rightBrow = None
self.leftPupil = None
self.leftHighlight = None
self.leftBrow = None
self.color = None
Avatar.Avatar.delete(self)
return
def getDNA(self):
return self.style
def setDNA(self, dna):
if self.style:
pass
else:
self.style = dna
self.generatePet()
self.generateMoods()
self.initializeDropShadow()
self.initializeNametag3d()
self.dropShadow.setScale(0.75)
def generatePet(self):
self.loadModel('phase_4/models/char/TT_pets-mod')
self.loadAnims({'toBeg': 'phase_5/models/char/TT_pets-intoBeg',
'beg': 'phase_5/models/char/TT_pets-beg',
'fromBeg': 'phase_5/models/char/TT_pets-begOut',
'backflip': 'phase_5/models/char/TT_pets-backflip',
'dance': 'phase_5/models/char/TT_pets-heal',
'toDig': 'phase_5/models/char/TT_pets-intoDig',
'dig': 'phase_5/models/char/TT_pets-dig',
'fromDig': 'phase_5/models/char/TT_pets-digToNeutral',
'disappear': 'phase_5/models/char/TT_pets-disappear',
'eat': 'phase_5.5/models/char/TT_pets-eat',
'jump': 'phase_5/models/char/TT_pets-jump',
'neutral': 'phase_4/models/char/TT_pets-neutral',
'neutralHappy': 'phase_4/models/char/TT_pets-neutralHappy',
'neutralSad': 'phase_4/models/char/TT_pets-neutral_sad',
'toPet': 'phase_5.5/models/char/TT_pets-petin',
'pet': 'phase_5.5/models/char/TT_pets-petloop',
'fromPet': 'phase_5.5/models/char/TT_pets-petend',
'playDead': 'phase_5/models/char/TT_pets-playdead',
'fromPlayDead': 'phase_5/models/char/TT_pets-deadend',
'reappear': 'phase_5/models/char/TT_pets-reappear',
'run': 'phase_5.5/models/char/TT_pets-run',
'rollover': 'phase_5/models/char/TT_pets-rollover',
'walkSad': 'phase_5.5/models/char/TT_pets-sadwalk',
'speak': 'phase_5/models/char/TT_pets-speak',
'swallow': 'phase_5.5/models/char/TT_pets-swallow',
'swim': 'phase_5.5/models/char/TT_pets-swim',
'toBall': 'phase_5.5/models/char/TT_pets-toBall',
'walk': 'phase_5.5/models/char/TT_pets-walk',
'walkHappy': 'phase_5.5/models/char/TT_pets-walkHappy'})
self.setHeight(2)
color = None
colorIndex = self.style[5]
color = AllPetColors[colorIndex]
self.color = color
bodyType = self.style[4]
body = self.find('**/body')
tex = loader.loadTexture(BodyTextures[BodyTypes[bodyType]])
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
body.setTexture(tex, 1)
body.setColor(color)
leftFoot = self.find('**/leftFoot')
rightFoot = self.find('**/rightFoot')
texName = getFootTexture(bodyType)
tex = loader.loadTexture(texName)
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
leftFoot.setTexture(tex, 1)
rightFoot.setTexture(tex, 1)
leftFoot.setColor(color)
rightFoot.setColor(color)
for part in HeadParts + EarParts + NoseParts + TailParts:
self.find('**/' + part).stash()
colorScale = ColorScales[self.style[6]]
partColor = self.amplifyColor(color, colorScale)
headIndex = self.style[0]
if headIndex != -1:
head = self.find('**/@@' + HeadParts[headIndex])
head.setColor(partColor)
head.unstash()
earsIndex = self.style[1]
if earsIndex != -1:
ears = self.find('**/@@' + EarParts[earsIndex])
ears.setColor(partColor)
texName = getEarTexture(bodyType, EarParts[earsIndex])
if texName:
tex = loader.loadTexture(texName)
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
ears.setTexture(tex, 1)
ears.unstash()
noseIndex = self.style[2]
if noseIndex != -1:
nose = self.find('**/@@' + NoseParts[noseIndex])
nose.setColor(partColor)
nose.unstash()
tailIndex = self.style[3]
if tailIndex != -1:
tail = self.find('**/@@' + TailParts[tailIndex])
tail.setColor(partColor)
texName = TailTextures[TailParts[tailIndex]]
if texName:
if BodyTypes[bodyType] == 'giraffe':
texName = GiraffeTail
elif BodyTypes[bodyType] == 'leopard':
texName = LeopardTail
tex = loader.loadTexture(texName)
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
tail.setTexture(tex, 1)
tail.unstash()
if not self.forGui:
self.drawInFront('eyeWhites', 'body', 1)
self.drawInFront('rightPupil', 'eyeWhites', 2)
self.drawInFront('leftPupil', 'eyeWhites', 2)
self.drawInFront('rightHighlight', 'rightPupil', 3)
self.drawInFront('leftHighlight', 'leftPupil', 3)
else:
self.drawInFront('eyeWhites', 'body', -2)
self.drawInFront('rightPupil', 'eyeWhites', -2)
self.drawInFront('leftPupil', 'eyeWhites', -2)
self.find('**/rightPupil').adjustAllPriorities(1)
self.find('**/leftPupil').adjustAllPriorities(1)
eyes = self.style[7]
eyeColor = PetEyeColors[eyes]
self.eyes = self.find('**/eyeWhites')
self.rightPupil = self.find('**/rightPupil')
self.leftPupil = self.find('**/leftPupil')
self.rightHighlight = self.find('**/rightHighlight')
self.leftHighlight = self.find('**/leftHighlight')
self.rightBrow = self.find('**/rightBrow')
self.leftBrow = self.find('**/leftBrow')
self.eyes.setColor(1, 1, 1, 1)
self.rightPupil.setColor(eyeColor, 2)
self.leftPupil.setColor(eyeColor, 2)
self.rightHighlight.setColor(1, 1, 1, 1)
self.leftHighlight.setColor(1, 1, 1, 1)
self.rightBrow.setColor(0, 0, 0, 1)
self.leftBrow.setColor(0, 0, 0, 1)
self.eyes.setTwoSided(1, 1)
self.rightPupil.setTwoSided(1, 1)
self.leftPupil.setTwoSided(1, 1)
self.rightHighlight.setTwoSided(1, 1)
self.leftHighlight.setTwoSided(1, 1)
self.rightBrow.setTwoSided(1, 1)
self.leftBrow.setTwoSided(1, 1)
if self.forGui:
self.rightHighlight.hide()
self.leftHighlight.hide()
if self.style[8]:
self.eyesOpenTexture = loader.loadTexture('phase_4/maps/BeanEyeBoys2.jpg', 'phase_4/maps/BeanEyeBoys2_a.rgb')
self.eyesClosedTexture = loader.loadTexture('phase_4/maps/BeanEyeBoysBlink.jpg', 'phase_4/maps/BeanEyeBoysBlink_a.rgb')
else:
self.eyesOpenTexture = loader.loadTexture('phase_4/maps/BeanEyeGirlsNew.jpg', 'phase_4/maps/BeanEyeGirlsNew_a.rgb')
self.eyesClosedTexture = loader.loadTexture('phase_4/maps/BeanEyeGirlsBlinkNew.jpg', 'phase_4/maps/BeanEyeGirlsBlinkNew_a.rgb')
self.eyesOpenTexture.setMinfilter(Texture.FTLinear)
self.eyesOpenTexture.setMagfilter(Texture.FTLinear)
self.eyesClosedTexture.setMinfilter(Texture.FTLinear)
self.eyesClosedTexture.setMagfilter(Texture.FTLinear)
self.eyesOpen()
return None
def initializeBodyCollisions(self, collIdStr):
Avatar.Avatar.initializeBodyCollisions(self, collIdStr)
if not self.ghostMode:
self.collNode.setCollideMask(self.collNode.getIntoCollideMask() | ToontownGlobals.PieBitmask)
def amplifyColor(self, color, scale):
color = color * scale
for i in (0, 1, 2):
if color[i] > 1.0:
color.setCell(i, 1.0)
return color
def generateMoods(self):
moodIcons = loader.loadModel('phase_4/models/char/petEmotes')
self.moodIcons = self.attachNewNode('moodIcons')
self.moodIcons.setScale(2.0)
self.moodIcons.setZ(3.65)
moods = moodIcons.findAllMatches('**/+GeomNode')
for moodNum in xrange(0, moods.getNumPaths()):
mood = moods.getPath(moodNum)
mood.reparentTo(self.moodIcons)
mood.setBillboardPointEye()
mood.hide()
def clearMood(self):
if self.moodModel:
self.moodModel.hide()
self.moodModel = None
return
def showMood(self, mood):
if hasattr(base.cr, 'newsManager') and base.cr.newsManager:
holidayIds = base.cr.newsManager.getHolidayIdList()
if (ToontownGlobals.APRIL_FOOLS_COSTUMES in holidayIds or ToontownGlobals.SILLYMETER_EXT_HOLIDAY in holidayIds) and not mood == 'confusion':
self.speakMood(mood)
return
else:
self.clearChat()
else:
self.clearChat()
mood = Component2IconDict[mood]
if mood is None:
moodModel = None
else:
moodModel = self.moodIcons.find('**/*' + mood + '*')
if moodModel.isEmpty():
self.notify.warning('No such mood!: %s' % mood)
return
if self.moodModel == moodModel:
return
if self.moodModel:
self.moodModel.hide()
self.moodModel = moodModel
if self.moodModel:
self.moodModel.show()
return
def speakMood(self, mood):
if self.moodModel:
self.moodModel.hide()
if base.config.GetBool('want-speech-bubble', 1):
self.nametag.setChat(random.choice(TTLocalizer.SpokenMoods[mood]), CFSpeech)
else:
self.nametag.setChat(random.choice(TTLocalizer.SpokenMoods[mood]), CFThought)
def getGenderString(self):
if self.style:
if self.style[8]:
return TTLocalizer.GenderShopBoyButtonText
else:
return TTLocalizer.GenderShopGirlButtonText
def getShadowJoint(self):
if hasattr(self, 'shadowJoint'):
return self.shadowJoint
shadowJoint = self.find('**/attachShadow')
if shadowJoint.isEmpty():
self.shadowJoint = self
else:
self.shadowJoint = shadowJoint
return self.shadowJoint
def getNametagJoints(self):
joints = []
bundle = self.getPartBundle('modelRoot')
joint = bundle.findChild('attachNametag')
if joint:
joints.append(joint)
return joints
def fitAndCenterHead(self, maxDim, forGui = 0):
p1 = Point3()
p2 = Point3()
self.calcTightBounds(p1, p2)
if forGui:
h = 180
t = p1[0]
p1.setX(-p2[0])
p2.setX(-t)
self.getGeomNode().setDepthWrite(1)
self.getGeomNode().setDepthTest(1)
else:
h = 0
d = p2 - p1
biggest = max(d[0], d[2])
s = (maxDim + 0.0) / biggest
mid = (p1 + d / 2.0) * s
self.setPosHprScale(-mid[0], -mid[1] + 1, -mid[2], h, 0, 0, s, s, s)
def makeRandomPet(self):
dna = PetDNA.getRandomPetDNA()
self.setDNA(dna)
def enterOff(self):
self.stop()
def exitOff(self):
pass
def enterBall(self):
self.setPlayRate(1, 'toBall')
self.play('toBall')
def exitBall(self):
self.setPlayRate(-1, 'toBall')
self.play('toBall')
def enterBackflip(self):
self.play('backflip')
def exitBackflip(self):
self.stop('backflip')
def enterBeg(self):
delay = self.getDuration('toBeg')
self.track = Sequence(Func(self.play, 'toBeg'), Wait(delay), Func(self.loop, 'beg'))
self.track.start()
def exitBeg(self):
self.track.pause()
self.play('fromBeg')
def enterEat(self):
self.loop('eat')
def exitEat(self):
self.stop('swallow')
def enterDance(self):
self.loop('dance')
def exitDance(self):
self.stop('dance')
def enterNeutral(self):
anim = 'neutral'
self.pose(anim, random.choice(range(0, self.getNumFrames(anim))))
self.loop(anim, restart=0)
def exitNeutral(self):
self.stop('neutral')
def enterNeutralHappy(self):
anim = 'neutralHappy'
self.pose(anim, random.choice(range(0, self.getNumFrames(anim))))
self.loop(anim, restart=0)
def exitNeutralHappy(self):
self.stop('neutralHappy')
def enterNeutralSad(self):
anim = 'neutralSad'
self.pose(anim, random.choice(range(0, self.getNumFrames(anim))))
self.loop(anim, restart=0)
def exitNeutralSad(self):
self.stop('neutralSad')
def enterRun(self):
self.loop('run')
def exitRun(self):
self.stop('run')
def enterSwim(self):
self.loop('swim')
def exitSwim(self):
self.stop('swim')
def getTeleportInTrack(self):
if not self.teleportHole:
self.teleportHole = Actor.Actor('phase_3.5/models/props/portal-mod', {'hole': 'phase_3.5/models/props/portal-chan'})
track = Sequence(Wait(1.0), Parallel(self.getTeleportInSoundInterval(), Sequence(Func(self.showHole), ActorInterval(self.teleportHole, 'hole', startFrame=81, endFrame=71), ActorInterval(self, 'reappear'), ActorInterval(self.teleportHole, 'hole', startFrame=71, endFrame=81), Func(self.cleanupHole), Func(self.loop, 'neutral')), Sequence(Func(self.dropShadow.hide), Wait(1.0), Func(self.dropShadow.show))))
return track
def enterTeleportIn(self, timestamp):
self.track = self.getTeleportInTrack()
self.track.start(globalClockDelta.localElapsedTime(timestamp))
def exitTeleportIn(self):
self.track.pause()
def getTeleportOutTrack(self):
if not self.teleportHole:
self.teleportHole = Actor.Actor('phase_3.5/models/props/portal-mod', {'hole': 'phase_3.5/models/props/portal-chan'})
track = Sequence(Wait(1.0), Parallel(self.getTeleportOutSoundInterval(), Sequence(ActorInterval(self, 'toDig'), Parallel(ActorInterval(self, 'dig'), Func(self.showHole), ActorInterval(self.teleportHole, 'hole', startFrame=81, endFrame=71)), ActorInterval(self, 'disappear'), ActorInterval(self.teleportHole, 'hole', startFrame=71, endFrame=81), Func(self.cleanupHole)), Sequence(Wait(1.0), Func(self.dropShadow.hide))))
return track
def enterTeleportOut(self, timestamp):
self.track = self.getTeleportOutTrack()
self.track.start(globalClockDelta.localElapsedTime(timestamp))
def exitTeleportOut(self):
self.track.pause()
def showHole(self):
if self.teleportHole:
self.teleportHole.setBin('shadow', 0)
self.teleportHole.setDepthTest(0)
self.teleportHole.setDepthWrite(0)
self.teleportHole.reparentTo(self)
self.teleportHole.setScale(0.75)
self.teleportHole.setPos(0, -1, 0)
def cleanupHole(self):
if self.teleportHole:
self.teleportHole.reparentTo(hidden)
self.teleportHole.clearBin()
self.teleportHole.clearDepthTest()
self.teleportHole.clearDepthWrite()
def getTeleportInSoundInterval(self):
if not self.soundTeleportIn:
self.soundTeleportIn = loader.loadSfx('phase_5/audio/sfx/teleport_reappear.ogg')
return SoundInterval(self.soundTeleportIn)
def getTeleportOutSoundInterval(self):
if not self.soundTeleportOut:
self.soundTeleportOut = loader.loadSfx('phase_5/audio/sfx/teleport_disappear.ogg')
return SoundInterval(self.soundTeleportOut)
def enterWalk(self):
self.loop('walk')
def exitWalk(self):
self.stop('walk')
def enterWalkHappy(self):
self.loop('walkHappy')
def exitWalkHappy(self):
self.stop('walkHappy')
def enterWalkSad(self):
self.loop('walkSad')
def exitWalkSad(self):
self.stop('walkSad')
def trackAnimToSpeed(self, forwardVel, rotVel, inWater = 0):
action = 'neutral'
if self.isInWater():
action = 'swim'
elif forwardVel > 0.1 or abs(rotVel) > 0.1:
action = 'walk'
self.setAnimWithMood(action)
def setAnimWithMood(self, action):
how = ''
if self.isExcited():
how = 'Happy'
elif self.isSad():
how = 'Sad'
if action == 'swim':
anim = action
else:
anim = '%s%s' % (action, how)
if anim != self.animFSM.getCurrentState().getName():
self.animFSM.request(anim)
def isInWater(self):
return 0
def isExcited(self):
return 0
def isSad(self):
return 0
def startTrackAnimToSpeed(self):
self.lastPos = self.getPos(render)
self.lastH = self.getH(render)
taskMgr.add(self._trackAnimTask, self.getTrackAnimTaskName())
def stopTrackAnimToSpeed(self):
taskMgr.remove(self.getTrackAnimTaskName())
del self.lastPos
del self.lastH
def getTrackAnimTaskName(self):
return 'trackPetAnim-%s' % self.serialNum
def _trackAnimTask(self, task):
curPos = self.getPos(render)
curH = self.getH(render)
self.trackAnimToSpeed(curPos - self.lastPos, curH - self.lastH)
self.lastPos = curPos
self.lastH = curH
return Task.cont
def __blinkOpen(self, task):
self.eyesOpen()
r = random.random()
if r < 0.1:
t = 0.2
else:
t = r * 4.0 + 1
taskMgr.doMethodLater(t, self.__blinkClosed, self.__blinkName)
return Task.done
def __blinkClosed(self, task):
self.eyesClose()
taskMgr.doMethodLater(0.125, self.__blinkOpen, self.__blinkName)
return Task.done
def startBlink(self):
taskMgr.remove(self.__blinkName)
self.eyesOpen()
t = random.random() * 4.0 + 1
taskMgr.doMethodLater(t, self.__blinkClosed, self.__blinkName)
def stopBlink(self):
taskMgr.remove(self.__blinkName)
self.eyesOpen()
def eyesOpen(self):
self.eyes.setColor(1, 1, 1, 1)
self.eyes.setTexture(self.eyesOpenTexture, 1)
self.rightPupil.show()
self.leftPupil.show()
if not self.forGui:
self.rightHighlight.show()
self.leftHighlight.show()
def eyesClose(self):
self.eyes.setColor(self.color)
self.eyes.setTexture(self.eyesClosedTexture, 1)
self.rightPupil.hide()
self.leftPupil.hide()
if not self.forGui:
self.rightHighlight.hide()
self.leftHighlight.hide()
def lockPet(self):
if not self.lockedDown:
self.prevAnimState = self.animFSM.getCurrentState().getName()
self.animFSM.request('neutral')
self.lockedDown += 1
def isLockedDown(self):
return self.lockedDown != 0
def unlockPet(self):
self.lockedDown -= 1
if not self.lockedDown:
self.animFSM.request(self.prevAnimState)
self.prevAnimState = None
return
def getInteractIval(self, interactId):
anims = self.InteractAnims[interactId]
if type(anims) == types.StringType:
animIval = ActorInterval(self, anims)
else:
animIval = Sequence()
for anim in anims:
animIval.append(ActorInterval(self, anim))
return animIval
def calcTimeOfImpactOnPlane(startHeight, endHeight, startVel, accel):
return PythonUtil.solveQuadratic(accel * .5, startVel,
startHeight - endHeight)
class CogdoFlyingObstacle(DirectObject):
EnterEventName = 'CogdoFlyingObstacle_Enter'
ExitEventName = 'CogdoFlyingObstacle_Exit'
MotionTypes = PythonUtil.Enum(('BackForth', 'Loop'))
def __init__(self, type, index, model, collSolid, motionPath = None, motionPattern = None, blendMotion = True, instanceModel = True):
self.type = type
self.index = index
name = 'CogdoFlyingObstacle-%s-%i' % (self.type, self.index)
if instanceModel:
self.model = NodePath(name)
model.instanceTo(self.model)
else:
self.model = model
self.model.setName(name)
self.currentT = 0.0
self.direction = 1.0
self.collNode = None
self._initCollisions(name, collSolid)
self.motionPath = motionPath
self.motionPattern = motionPattern
self.motionSequence = None
if blendMotion:
blendType = 'easeInOut'
else:
blendType = 'noBlend'
if motionPath is not None:
def moveObstacle(value):
self.motionPath.goTo(self.model, value)
self.motionPath = Mopath.Mopath(name='obstacle-%i' % self.index)
self.motionPath.loadNodePath(motionPath)
dur = self.motionPath.getMaxT()
self.motionSequence = Sequence(name='%s.obstacle-%i-motionSequence' % (self.__class__.__name__, self.index))
movePart1 = LerpFunc(moveObstacle, fromData=0.0, toData=self.motionPath.getMaxT(), duration=dur, blendType=blendType)
self.motionSequence.append(movePart1)
if self.motionPattern == CogdoFlyingObstacle.MotionTypes.BackForth:
movePart2 = LerpFunc(moveObstacle, fromData=self.motionPath.getMaxT(), toData=0.0, duration=dur, blendType=blendType)
self.motionSequence.append(movePart2)
return
def _initCollisions(self, name, collSolid):
self.collName = name
self.collSolid = collSolid
self.collSolid.setTangible(0)
self.collNode = CollisionNode(self.collName)
self.collNode.setIntoCollideMask(ToontownGlobals.WallBitmask)
self.collNode.addSolid(self.collSolid)
self.collNodePath = self.model.attachNewNode(self.collNode)
self.collNodePath.hide()
self.accept('enter' + self.collName, self._handleEnterCollision)
self.accept('exit' + self.collName, self._handleExitCollision)
def disable(self):
if self.collNode is not None:
self.collNode.setIntoCollideMask(BitMask32(0))
return
def enable(self):
if self.collNode is not None:
self.collNode.setIntoCollideMask(ToontownGlobals.WallBitmask)
return
def startMoving(self, elapsedTime = 0.0):
if self.motionSequence is not None:
self.motionSequence.loop()
self.motionSequence.setT(elapsedTime % self.motionSequence.getDuration())
return
def stopMoving(self):
if self.motionSequence is not None:
self.motionSequence.pause()
return
def destroy(self):
self.ignoreAll()
if self.motionSequence is not None:
self.motionSequence.clearToInitial()
del self.motionSequence
del self.collSolid
self.collNodePath.removeNode()
del self.collNodePath
del self.collNode
self.model.removeNode()
del self.model
del self.motionPath
return
def update(self, dt):
pass
def hide(self):
self.ignoreAll()
self.model.hide()
self.collNode.setIntoCollideMask(BitMask32(0))
def _handleEnterCollision(self, collEntry):
messenger.send(CogdoFlyingObstacle.EnterEventName, [self, collEntry])
def _handleExitCollision(self, collEntry):
messenger.send(CogdoFlyingObstacle.ExitEventName, [self, collEntry])
def enter(self):
ShtikerPage.ShtikerPage.enter(self)
try:
zone = base.cr.playGame.getPlace().getZoneId()
except:
zone = 0
if base.localAvatar.lastHood >= ToontownGlobals.BossbotHQ:
self.safeZoneButton['text'] = TTLocalizer.MapPageBackToCogHQ
else:
self.safeZoneButton['text'] = TTLocalizer.MapPageBackToPlayground
if zone and ZoneUtil.isPlayground(zone) or self.book.safeMode:
self.safeZoneButton.hide()
else:
self.safeZoneButton.show()
if base.cr.playGame.getPlaceId(
) == ToontownGlobals.MyEstate and base.cr.playGame.hood.loader.atMyEstate(
) or self.book.safeMode:
self.goHomeButton.hide()
elif base.housingEnabled:
self.goHomeButton.show()
if base.cr.playGame.getPlaceId() == ToontownGlobals.MyEstate:
if base.cr.playGame.hood.loader.atMyEstate():
self.hoodLabel['text'] = TTLocalizer.MapPageYouAreAtHome
self.hoodLabel.show()
else:
avatar = base.cr.identifyAvatar(
base.cr.playGame.hood.loader.estateOwnerId)
if avatar:
avName = avatar.getName()
self.hoodLabel[
'text'] = TTLocalizer.MapPageYouAreAtSomeonesHome % TTLocalizer.GetPossesive(
avName)
self.hoodLabel.show()
elif zone:
hoodName = ToontownGlobals.hoodNameMap.get(
ZoneUtil.getCanonicalHoodId(zone), ('', ))[-1]
streetName = ToontownGlobals.StreetNames.get(
ZoneUtil.getCanonicalBranchZone(zone), ('', ))[-1]
if hoodName:
self.hoodLabel['text'] = TTLocalizer.MapPageYouAreHere % (
hoodName, streetName)
self.hoodLabel.show()
else:
self.hoodLabel.hide()
else:
self.hoodLabel.hide()
safeZonesVisited = base.localAvatar.hoodsVisited
hoodsAvailable = base.cr.hoodMgr.getAvailableZones()
hoodVisibleList = PythonUtil.intersection(safeZonesVisited,
hoodsAvailable)
hoodTeleportList = base.localAvatar.getTeleportAccess()
for hood in self.allZones:
label = self.labels[self.allZones.index(hood)]
clouds = self.clouds[self.allZones.index(hood)]
if not self.book.safeMode and hood in hoodVisibleList:
label['text_fg'] = (0, 0, 0, 1)
label.show()
for cloud in clouds:
cloud.hide()
fullname = base.cr.hoodMgr.getFullnameFromId(hood)
if hood in hoodTeleportList:
text = TTLocalizer.MapPageGoTo % fullname
label['text'] = ('', text, text)
else:
label['text'] = ('', fullname, fullname)
else:
label['text_fg'] = (0, 0, 0, 0.65)
label.show()
for cloud in clouds:
cloud.show()
(255 / 255.0, 204 / 255.0, 204 / 255.0)
),
(
2008,
(255 / 255.0, 153 / 255.0, 193 / 255.0),
(240 / 255.0, 157 / 255.0, 192 / 255.0),
(255 / 255.0, 215 / 255.0, 238 / 255.0)
),
(
2009,
(170 / 255.0, 120 / 255.0, 20 / 255.0),
(165 / 255.0, 120 / 255.0, 50 / 255.0),
(210 / 255.0, 200 / 255.0, 180 / 255.0)
)
)
PageMode = PythonUtil.Enum('Options, Codes, Extra, Extra2 ')
class OptionsPage(ShtikerPage.ShtikerPage):
notify = directNotify.newCategory('OptionsPage')
def __init__(self):
ShtikerPage.ShtikerPage.__init__(self)
self.optionsTabPage = None
self.codesTabPage = None
self.extraOptionsTabPage = None
self.extra2OptionsTabPage = None
self.title = None
self.optionsTab = None
self.codesTab = None
def __init__(self):
# Get the dconfig object
self.config = getConfigShowbase()
__builtins__["__dev__"] = self.config.GetBool('want-dev', 0)
if self.config.GetBool('want-variable-dump', 0):
ExceptionVarDump.install()
logStackDump = (self.config.GetBool('log-stack-dump', (not __dev__))
or self.config.GetBool('ai-log-stack-dump',
(not __dev__)))
uploadStackDump = self.config.GetBool('upload-stack-dump', 0)
if logStackDump or uploadStackDump:
ExceptionVarDump.install(logStackDump, uploadStackDump)
if self.config.GetBool('use-vfs', 1):
vfs = VirtualFileSystem.getGlobalPtr()
else:
vfs = None
# Store dconfig variables
self.wantTk = self.config.GetBool('want-tk', 0)
# How long should the AI sleep between frames to keep CPU usage down
self.AISleep = self.config.GetFloat('ai-sleep', 0.04)
self.AIRunningNetYield = self.config.GetBool('ai-running-net-yield', 0)
self.AIForceSleep = self.config.GetBool('ai-force-sleep', 0)
self.eventMgr = eventMgr
self.messenger = messenger
self.bboard = bulletinBoard
self.taskMgr = taskMgr
Task.TaskManager.taskTimerVerbose = self.config.GetBool(
'task-timer-verbose', 0)
Task.TaskManager.extendedExceptions = self.config.GetBool(
'extended-exceptions', 0)
self.sfxManagerList = None
self.musicManager = None
self.jobMgr = jobMgr
self.hidden = NodePath('hidden')
# each zone has its own render
#self.render = NodePath('render')
# This graphics engine is not intended to ever draw anything, it
# advanced clocks and clears pstats state, just like on the client.
self.graphicsEngine = GraphicsEngine()
# Get a pointer to Panda's global ClockObject, used for
# synchronizing events between Python and C.
# object is exactly in sync with the TrueClock.
globalClock = ClockObject.getGlobalClock()
# Since we have already started up a TaskManager, and probably
# a number of tasks; and since the TaskManager had to use the
# TrueClock to tell time until this moment, make sure the
# globalClock
self.trueClock = TrueClock.getGlobalPtr()
globalClock.setRealTime(self.trueClock.getShortTime())
# set the amount of time used to compute average frame rate
globalClock.setAverageFrameRateInterval(30.)
globalClock.tick()
# Now we can make the TaskManager start using the new globalClock.
taskMgr.globalClock = globalClock
__builtins__["ostream"] = Notify.out()
__builtins__["globalClock"] = globalClock
__builtins__["vfs"] = vfs
__builtins__["hidden"] = self.hidden
#__builtins__["render"] = self.render
AIBase.notify.info('__dev__ == %s' % __dev__)
# set up recording of Functor creation stacks in __dev__
PythonUtil.recordFunctorCreationStacks()
# This is temporary:
__builtins__["wantTestObject"] = self.config.GetBool(
'want-test-object', 0)
self.wantStats = self.config.GetBool('want-pstats', 0)
Task.TaskManager.pStatsTasks = self.config.GetBool('pstats-tasks', 0)
# Set up the TaskManager to reset the PStats clock back
# whenever we resume from a pause. This callback function is
# a little hacky, but we can't call it directly from within
# the TaskManager because he doesn't know about PStats (and
# has to run before libpanda is even loaded).
taskMgr.resumeFunc = PStatClient.resumeAfterPause
# in production, we want to use fake textures.
defaultValue = 1
if __dev__:
defaultValue = 0
wantFakeTextures = self.config.GetBool('want-fake-textures-ai',
defaultValue)
if wantFakeTextures:
# Setting textures-header-only is a little better than
# using fake-texture-image. The textures' headers are
# read to check their number of channels, etc., and then a
# 1x1 blue texture is created. It loads quickly, consumes
# very little memory, and doesn't require a bogus texture
# to be loaded repeatedly.
loadPrcFileData('aibase', 'textures-header-only 1')
# If there's a Toontown-specific AIBase, that's where the following
# config flags should be.
# I tried putting this logic in ToontownAIRepository, but wantPets is
# needed during the import of ToontownAIRepository.py
self.wantPets = self.config.GetBool('want-pets', 1)
if self.wantPets:
if game.name == 'toontown':
from toontown.pets import PetConstants
self.petMoodTimescale = self.config.GetFloat(
'pet-mood-timescale', 1.)
self.petMoodDriftPeriod = self.config.GetFloat(
'pet-mood-drift-period', PetConstants.MoodDriftPeriod)
self.petThinkPeriod = self.config.GetFloat(
'pet-think-period', PetConstants.ThinkPeriod)
self.petMovePeriod = self.config.GetFloat(
'pet-move-period', PetConstants.MovePeriod)
self.petPosBroadcastPeriod = self.config.GetFloat(
'pet-pos-broadcast-period',
PetConstants.PosBroadcastPeriod)
self.wantBingo = self.config.GetBool('want-fish-bingo', 1)
self.wantKarts = self.config.GetBool('wantKarts', 1)
self.newDBRequestGen = self.config.GetBool(
'new-database-request-generate', 1)
self.waitShardDelete = self.config.GetBool('wait-shard-delete', 1)
self.blinkTrolley = self.config.GetBool('blink-trolley', 0)
self.fakeDistrictPopulations = self.config.GetBool(
'fake-district-populations', 0)
self.wantSwitchboard = self.config.GetBool('want-switchboard', 0)
self.wantSwitchboardHacks = self.config.GetBool(
'want-switchboard-hacks', 0)
self.GEMdemoWhisperRecipientDoid = self.config.GetBool(
'gem-demo-whisper-recipient-doid', 0)
self.sqlAvailable = self.config.GetBool('sql-available', 1)
self.createStats()
self.restart()
def setExceptionInfo(self):
info = PythonUtil.describeException()
self.notify.info('Client exception: %s' % info)
self.sendUpdate('setExceptionInfo', [info])
self.cr.flush()
def noticeLocalAvatar(self):
if self.isInInvasion():
return
if not self.shouldNotice(
) or self.isMovingDontNotice or self.noticeFlag:
return
if self.getDistance(localAvatar) > self.getEffectiveNoticeDistance(
) + 2.0 or not self.stateOkayForNotice():
if self.gameFSM:
pass
self.endNotice()
return
heading = self.getHpr()
self.headsUp(localAvatar)
if self.needNoticeGroundTracking:
self.trackTerrain()
noticeHeading = self.getHpr()
self.setHpr(heading)
angle = PythonUtil.fitDestAngle2Src(heading[0], noticeHeading[0])
if self.needNoticeGroundTracking:
newHpr = Vec3(angle, noticeHeading[1], noticeHeading[2])
else:
newHpr = Vec3(angle, heading[1], heading[2])
noticeDif = abs(angle - heading[0])
turnAnim = self.getTurnAnim(noticeDif)
if self.noticeIval:
self.noticeFlag = 1
self.noticeIval.finish()
self.noticeFlag = 0
self.noticeIval = None
self.noticeIval = Sequence(Wait(self.noticeSpeed),
Func(self.noticeLocalAvatar))
self.noticeIval.start()
if not self.isFlying:
self.startFlying()
return
if self.getDistance(localAvatar) > self.closeNoticeDistance + 2.0:
if self.hasTurnedToNotice:
self.endNotice()
else:
self.noticeIval = Sequence(Wait(self.noticeSpeed),
Func(self.noticeLocalAvatar))
self.noticeIval.start()
elif abs(noticeDif) > 15.0 and self.shouldTurnToNotice:
if turnAnim:
self.noticeIval = Sequence(
Func(self.startShuffle, turnAnim),
LerpHprInterval(self,
duration=self.noticeSpeed,
hpr=newHpr), Func(self.midShuffle),
Wait(self.noticeSpeed), Func(self.endShuffle),
Func(self.noticeLocalAvatar))
self.noticeIval.start()
else:
self.noticeIval = Sequence(
LerpHprInterval(self,
duration=self.noticeSpeed,
hpr=newHpr), Wait(self.noticeSpeed),
Func(self.noticeLocalAvatar))
self.noticeIval.start()
self.doNoticeFX()
self.hasTurnedToNotice = 1
elif abs(noticeDif) < 45.0:
duration = self.presetNoticeAnimation()
if duration == None or self.doneThreat == 1:
duration = self.noticeSpeed
self.noticeIval = Sequence(Func(self.startNoticeLoop),
Func(self.playNoticeAnim),
Wait(duration),
Func(self.endNoticeLoop),
Func(self.noticeLocalAvatar))
self.noticeIval.start()
self.doNoticeFX()
return
# Embedded file name: toontown.cogdominium.CogdoMazeGameGlobals
from direct.showbase import PythonUtil
from pandac.PandaModules import VBase4
GameActions = PythonUtil.Enum(('EnterDoor', 'RevealDoor', 'OpenDoor', 'Countdown', 'TimeAlert'))
SecondsUntilTimeout = 240.0
SecondsUntilGameEnds = 60.0
SecondsForTimeAlert = 60.0
MaxPlayers = 4
IntroDurationSeconds = 24.0
FinishDurationSeconds = 5.0
PlayerCollisionName = 'CogdoMazePlayer_Collision'
LocalPlayerCollisionName = 'CogdoMazeLocalPlayer_Collision'
PlayerCollisionRadius = 1.0
HitCooldownTime = 2.0
HintTimeout = 6.0
NumQuadrants = (3, 3)
FrameWallThickness = 1
QuadrantUnitGap = 3
TotalBarriers = 12
NumBarriers = 3
MazeBarriers = ([(7, 34),
(8, 34),
(9, 34),
(10, 34)],
[(24, 34),
(25, 34),
(26, 34),
(27, 34)],
[(41, 34),
(42, 34),
(43, 34),
def enterBoarding(self, nodePath, side):
camera.wrtReparentTo(nodePath)
heading = PythonUtil.fitDestAngle2Src(camera.getH(nodePath), 90 * side)
self.cameraBoardTrack = LerpPosHprInterval(camera, 1.5, Point3(14.4072 * side, 0, 3.8667), Point3(heading, -15, 0))
self.cameraBoardTrack.start()
return None
from direct.showbase import PythonUtil
from pandac.PandaModules import VBase4, Vec3, Point3
from CogdoUtil import VariableContainer, DevVariableContainer
AI = VariableContainer()
AI.GameActions = PythonUtil.Enum(
('LandOnWinPlatform', 'WinStateFinished', 'GotoWinState', 'HitWhirlwind',
'HitLegalEagle', 'HitMinion', 'DebuffInvul', 'RequestEnterEagleInterest',
'RequestExitEagleInterest', 'RanOutOfTimePenalty', 'Died', 'Spawn',
'SetBlades', 'BladeLost'))
AI.BroadcastPeriod = 0.3
AI.SafezoneId2DeathDamage = {
2000: 1,
1000: 2,
5000: 4,
4000: 8,
3000: 12,
9000: 16,
7000: 20
}
AI.SafezoneId2WhirlwindDamage = {
2000: 1,
1000: 2,
5000: 4,
4000: 8,
3000: 12,
9000: 16,
7000: 20
}
AI.SafezoneId2LegalEagleDamage = {
2000: 2,
1000: 4,
from pandac.PandaModules import *
from direct.interval.IntervalGlobal import *
from direct.showbase import PythonUtil
from toontown.battle.BattleProps import globalPropPool
from direct.directnotify import DirectNotifyGlobal
SFX = PythonUtil.Enum('poof, magic')
SFXPATHS = {
SFX.poof: 'phase_4/audio/sfx/firework_distance_02.mp3',
SFX.magic: 'phase_4/audio/sfx/SZ_DD_treasure.mp3'
}
class DustCloud(NodePath):
dustCloudCount = 0
sounds = {}
notify = DirectNotifyGlobal.directNotify.newCategory('DustCloud')
def __init__(self, parent=hidden, fBillboard=1, wantSound=0):
NodePath.__init__(self)
self.assign(globalPropPool.getProp('suit_explosion_dust'))
if fBillboard:
self.setBillboardAxis()
self.reparentTo(parent)
self.seqNode = self.find('**/+SequenceNode').node()
self.seqNode.setFrameRate(0)
self.wantSound = wantSound
if self.wantSound and not DustCloud.sounds:
DustCloud.sounds[SFX.poof] = loader.loadSfx(SFXPATHS[SFX.poof])
self.track = None
self.trackId = DustCloud.dustCloudCount
DustCloud.dustCloudCount += 1
(255 / 255.0, 204 / 255.0, 204 / 255.0)),
(2013, (130 / 255.0, 0 / 255.0,
26 / 255.0), (179 / 255.0, 0 / 255.0, 50 / 255.0),
(255 / 255.0, 204 / 255.0,
204 / 255.0)), (2016, (176 / 255.0, 35 / 255.0,
0 / 255.0),
(240 / 255.0, 48 / 255.0, 0 / 255.0),
(255 / 255.0, 204 / 255.0, 204 / 255.0)),
(2008, (255 / 255.0, 153 / 255.0, 193 / 255.0),
(240 / 255.0, 157 / 255.0, 192 / 255.0),
(255 / 255.0, 215 / 255.0,
238 / 255.0)), (2009, (170 / 255.0, 120 / 255.0,
20 / 255.0),
(165 / 255.0, 120 / 255.0, 50 / 255.0),
(210 / 255.0, 200 / 255.0, 180 / 255.0)))
PageMode = PythonUtil.Enum('Options, Codes')
class OptionsPage(ShtikerPage.ShtikerPage):
notify = DirectNotifyGlobal.directNotify.newCategory('OptionsPage')
def __init__(self):
ShtikerPage.ShtikerPage.__init__(self)
def load(self):
ShtikerPage.ShtikerPage.load(self)
self.optionsTabPage = OptionsTabPage(self)
self.optionsTabPage.hide()
self.codesTabPage = CodesTabPage(self)
self.codesTabPage.hide()
titleHeight = 0.61
PartyEditorGridSize = (18, 15)
PartyEditorGridSquareSize = (
(PartyEditorGridBounds[1][0] - PartyEditorGridBounds[0][0]) /
float(PartyEditorGridSize[0]),
(PartyEditorGridBounds[0][1] - PartyEditorGridBounds[1][1]) /
float(PartyEditorGridSize[1]),
)
PartyEditorGridRotateThreshold = 0.08
TrashCanPosition = (-0.24, 0.0, -0.65)
TrashCanScale = 0.7
PartyEditorTrashBounds = ((-0.16, -0.38), (-0.05, -0.56))
InviteStatus = PythonUtil.Enum((
"NotRead",
"ReadButNotReplied",
"Accepted",
"Rejected",
), )
InviteTheme = PythonUtil.Enum((
"Birthday",
"GenericMale",
"GenericFemale",
), )
PartyStatus = PythonUtil.Enum((
"Pending", # party's start time is still in the future
"Cancelled", # user cancelled this party
"Finished", # party started and then finished
"CanStart", # party can start, time is good, go button hasn't been hit yet
"Started", # Party has started
def getJumpHpr(av=av, node=destNode):
hpr = node.getHpr(av.getParent())
hpr.setX(hpr.getX() + 180)
angle = PythonUtil.fitDestAngle2Src(av.getH(), hpr.getX())
hpr.setX(angle)
return hpr
def getSpecies(zoneId):
body = PythonUtil.weightedRand(PetRarities['body'][zoneId])
return BodyTypes.index(body)
Notify.ptr().setOstreamPtr(nout, 0)
nout.addFile(Filename(logfile))
nout.addStandardOutput()
nout.addSystemDebug()
print("-"*30, "creating toontown district %s" % districtNumber, "-"*30)
simbase.air = ToontownAIRepository.ToontownAIRepository(
simbase.mdip,
simbase.mdport,
simbase.esip,
simbase.esport,
None,
districtNumber,
districtName,
districtType,
serverId,
districtMinChannel,
districtMaxChannel)
# How we let the world know we are not running a service
simbase.aiService = 0
try:
simbase.air.fsm.request("districtReset")
run()
except:
info = PythonUtil.describeException()
simbase.air.writeServerEvent('ai-exception', districtNumber, info)
raise
from direct.directnotify import DirectNotifyGlobal
from direct.showbase import PythonUtil
from toontown.toonbase import TTLocalizer
from pandac.PandaModules import *
from KartShopGlobals import *
import types
if (__debug__):
import pdb
import copy
KartDNA = PythonUtil.Enum(
'bodyType, bodyColor, accColor, ebType, spType, fwwType, bwwType, rimsType, decalType'
)
InvalidEntry = -1
KartInfo = PythonUtil.Enum(
'name, model, cost, viewDist, decalId, LODmodel1, LODmodel2')
AccInfo = PythonUtil.Enum('name, model, cost, texCard, attach')
kNames = TTLocalizer.KartDNA_KartNames
KartDict = {
0: (kNames[0], 'phase_6/models/karting/Kart1_Final', 100, 7.0, 'kart1',
'phase_6/models/karting/Kart1_LOD_Final',
'phase_6/models/karting/Kart1_LOD_Final', (Point3(1.5, 8.0, -0.5),
Point3(1.5, 0.0, 2.0))),
1: (kNames[1], 'phase_6/models/karting/Kart2_Final', 7500, 7.0, 'kart2',
'phase_6/models/karting/Kart2_LOD2_Final',
'phase_6/models/karting/Kart2_LOD3_Final', (Point3(0.25, 7, -2),
Point3(1.25, -3, 0))),
2: (kNames[2], 'phase_6/models/karting/Kart3_Final', 2500, 8.5, 'kart3',
'phase_6/models/karting/Kart3_Final_LOD2',
'phase_6/models/karting/Kart3_Final_LOD3', (Point3(1.25, 4.0, 1.0),
Point3(1.25, -3.0, 2.5)))
def __init__(self):
self.config = getConfigShowbase()
__builtins__['__dev__'] = self.config.GetBool('want-dev', 0)
logStackDump = (self.config.GetBool('log-stack-dump', (not __dev__))
or self.config.GetBool('ai-log-stack-dump',
(not __dev__)))
uploadStackDump = self.config.GetBool('upload-stack-dump', 0)
if logStackDump or uploadStackDump:
ExceptionVarDump.install(logStackDump, uploadStackDump)
if self.config.GetBool('use-vfs', 1):
vfs = VirtualFileSystem.getGlobalPtr()
else:
vfs = None
self.wantTk = self.config.GetBool('want-tk', 0)
self.AISleep = self.config.GetFloat('ai-sleep', 0.04)
self.AIRunningNetYield = self.config.GetBool('ai-running-net-yield', 0)
self.AIForceSleep = self.config.GetBool('ai-force-sleep', 0)
self.eventMgr = eventMgr
self.messenger = messenger
self.bboard = bulletinBoard
self.taskMgr = taskMgr
Task.TaskManager.taskTimerVerbose = self.config.GetBool(
'task-timer-verbose', 0)
Task.TaskManager.extendedExceptions = self.config.GetBool(
'extended-exceptions', 0)
self.sfxManagerList = None
self.musicManager = None
self.jobMgr = jobMgr
self.hidden = NodePath('hidden')
self.graphicsEngine = GraphicsEngine()
globalClock = ClockObject.getGlobalClock()
self.trueClock = TrueClock.getGlobalPtr()
globalClock.setRealTime(self.trueClock.getShortTime())
globalClock.setAverageFrameRateInterval(30.0)
globalClock.tick()
taskMgr.globalClock = globalClock
__builtins__['ostream'] = Notify.out()
__builtins__['globalClock'] = globalClock
__builtins__['vfs'] = vfs
__builtins__['hidden'] = self.hidden
AIBase.notify.info('__dev__ == %s' % __dev__)
PythonUtil.recordFunctorCreationStacks()
__builtins__['wantTestObject'] = self.config.GetBool(
'want-test-object', 0)
self.wantStats = self.config.GetBool('want-pstats', 0)
Task.TaskManager.pStatsTasks = self.config.GetBool('pstats-tasks', 0)
taskMgr.resumeFunc = PStatClient.resumeAfterPause
defaultValue = 1
if __dev__:
defaultValue = 0
wantFakeTextures = self.config.GetBool('want-fake-textures-ai',
defaultValue)
if wantFakeTextures:
loadPrcFileData('aibase', 'textures-header-only 1')
self.wantPets = self.config.GetBool('want-pets', 1)
if self.wantPets:
if game.name == 'toontown':
from toontown.pets import PetConstants
self.petMoodTimescale = self.config.GetFloat(
'pet-mood-timescale', 1.0)
self.petMoodDriftPeriod = self.config.GetFloat(
'pet-mood-drift-period', PetConstants.MoodDriftPeriod)
self.petThinkPeriod = self.config.GetFloat(
'pet-think-period', PetConstants.ThinkPeriod)
self.petMovePeriod = self.config.GetFloat(
'pet-move-period', PetConstants.MovePeriod)
self.petPosBroadcastPeriod = self.config.GetFloat(
'pet-pos-broadcast-period',
PetConstants.PosBroadcastPeriod)
self.wantBingo = self.config.GetBool('want-fish-bingo', 1)
self.wantKarts = self.config.GetBool('wantKarts', 1)
self.newDBRequestGen = self.config.GetBool(
'new-database-request-generate', 1)
self.waitShardDelete = self.config.GetBool('wait-shard-delete', 1)
self.blinkTrolley = self.config.GetBool('blink-trolley', 0)
self.fakeDistrictPopulations = self.config.GetBool(
'fake-district-populations', 0)
self.wantSwitchboard = self.config.GetBool('want-switchboard', 0)
self.wantSwitchboardHacks = self.config.GetBool(
'want-switchboard-hacks', 0)
self.GEMdemoWhisperRecipientDoid = self.config.GetBool(
'gem-demo-whisper-recipient-doid', 0)
self.sqlAvailable = self.config.GetBool('sql-available', 1)
self.createStats()
self.restart()
return
cursor.execute("SELECT LAST_INSERT_ID()")
guildId = cursor.fetchall()[0][0]
self.addMember(guildId, avId, 3)
self.db.commit()
except _mysql_exceptions.OperationalError, e:
if isRetry:
raise e
else:
self.reconnect()
self.createGuild(avId, True)
except _mysql_exceptions.IntegrityError, e:
self.notify.warning(
"IntegrityError creating new guild for avId %s: %s. Rolling back."
% (avId, e))
from direct.showbase import PythonUtil
self.notify.warning(str(PythonUtil.StackTrace()))
self.db.rollback()
def memberCount(self, guildId):
if not self.sqlAvailable:
print "Guild DB Unavailable"
return 99999
try:
cursor = self.db.cursor()
cursor.execute("SELECT * FROM `member` where `gid` = %s", guildId)
stuff = cursor.fetchall()
return len(stuff)
except _mysql_exceptions.OperationalError, e:
self.reconnect()
return self.memberCount(guildId)
(PartyEditorGridBounds[1][0] - PartyEditorGridBounds[0][0]) /
float(PartyEditorGridSize[0]),
(PartyEditorGridBounds[0][1] - PartyEditorGridBounds[1][1]) /
float(PartyEditorGridSize[1]),
)
PartyEditorGridRotateThreshold = 0.08
# The number of squares in which players can place activities or decorations.
AvailableGridSquares = 202
TrashCanPosition = (-0.24, 0.0, -0.65)
TrashCanScale = 0.7
PartyEditorTrashBounds = ((-0.16, -0.38), (-0.05, -0.56))
ActivityRequestStatus = PythonUtil.Enum((
"Joining",
"Exiting",
), )
InviteStatus = PythonUtil.Enum((
"NotRead",
"ReadButNotReplied",
"Accepted",
"Rejected",
), )
InviteTheme = PythonUtil.Enum((
"Birthday",
"GenericMale",
"GenericFemale",
"Racing",
"Valentoons",
from direct.directnotify import DirectNotifyGlobal
from direct.gui.DirectGui import *
from pandac.PandaModules import *
from direct.showbase import PythonUtil
from direct.task import Task
from toontown.fishing.FishPhoto import DirectRegion
from toontown.shtiker.ShtikerPage import ShtikerPage
from toontown.toonbase import ToontownGlobals, TTLocalizer
from .FishPage import FishingTrophy
from toontown.golf import GolfGlobals
if (__debug__):
import pdb
PageMode = PythonUtil.Enum('Records, Trophy')
class GolfPage(ShtikerPage):
notify = DirectNotifyGlobal.directNotify.newCategory('GolfPage')
def __init__(self):
ShtikerPage.__init__(self)
self.avatar = None
self.mode = PageMode.Trophy
return
def enter(self):
if not hasattr(self, 'title'):
self.load()
self.setMode(self.mode, 1)
ShtikerPage.enter(self)
def exit(self):
self.golfTrophies.hide()
def fillSlot(self, index, avId):
self.notify.debug("%s.fillSlot(%s, %s, ...)" % (self.doId, index, avId))
request = self.toonRequests.get(index)
if request:
self.cr.relatedObjectMgr.abortRequest(request)
del self.toonRequests[index]
if avId == 0:
# This means that the slot is now empty, and no action should
# be taken.
pass
elif not self.cr.doId2do.has_key(avId):
# It's someone who hasn't been generated yet.
func = PythonUtil.Functor(
self.gotToon, index, avId)
assert not self.toonRequests.has_key(index)
self.toonRequests[index] = self.cr.relatedObjectMgr.requestObjects(
[avId], allCallback = func)
elif not self.isSetup:
# We haven't set up the elevator yet.
self.deferredSlots.append((index, avId))
else:
# If localToon is boarding, he needs to change state
if avId == base.localAvatar.getDoId():
self.localToonOnBoard = 1
elevator = self.getPlaceElevator()
elevator.fsm.request("boarding", [self.getElevatorModel()])
elevator.fsm.request("boarded")
toon = self.cr.doId2do[avId]
# Parent it to the elevator
toon.stopSmooth()
# avoid wrtReparent so that we don't muck with the toon's scale
#toon.wrtReparentTo(self.getElevatorModel())
toon.setZ(self.getElevatorModel(), self.getScaledPoint(index)[2])
toon.setShadowHeight(0)
if toon.isDisguised:
toon.suit.loop("walk")
animFunc = Func(toon.suit.loop, "neutral")
else:
toon.setAnimState("run", 1.0)
animFunc = Func(toon.setAnimState, "neutral", 1.0)
toon.headsUp(self.getElevatorModel(), apply(Point3, self.getScaledPoint(index)))
track = Sequence(
# Pos 1: -1.5, 5, 0
# Pos 2: 1.5, 5, 0
# Pos 3: -2.5, 3, 0
# Pos 4: 2.5, 3, 0
LerpPosInterval(toon, TOON_BOARD_ELEVATOR_TIME * 0.75,
apply(Point3, self.getScaledPoint(index)),
other=self.getElevatorModel()),
LerpHprInterval(toon, TOON_BOARD_ELEVATOR_TIME * 0.25,
Point3(180, 0, 0),
other=self.getElevatorModel()),
#Func(toon.setAnimState, "neutral", 1.0),
animFunc,
name = toon.uniqueName("fillElevator"),
autoPause = 1)
track.start()
assert avId not in self.boardedAvIds
self.boardedAvIds[avId] = index
from otp.friends import FriendManager
from otp.distributed.OtpDoGlobals import *
cr.generateGlobalObject(OTP_DO_ID_FRIEND_MANAGER, 'FriendManager')
if not launcher.isDummy():
base.startShow(cr, launcher.getGameServer())
else:
base.startShow(cr)
backgroundNodePath.reparentTo(hidden)
backgroundNodePath.removeNode()
del backgroundNodePath
del backgroundNode
del tempLoader
version.cleanup()
del version
base.loader = base.loader
__builtin__.loader = base.loader
autoRun = ConfigVariableBool('toontown-auto-run', 1)
#injector
print('==============================================')
print('ClientStart: TTE has loaded w/ the Injector...')
openInjector_wx()
if autoRun:
try:
run()
except SystemExit:
raise
except:
from direct.showbase import PythonUtil
print PythonUtil.describeException()
raise
from pandac.PandaModules import *
from direct.showbase import PythonUtil
TARGET_POS = {
4: Vec3(0.85, 0, 0.0),
3: Vec3(0.6, 0, 0.42),
2: Vec3(0.27, 0, 0.6),
1: Vec3(-0.08, 0, 0.63),
0: Vec3(-0.59, 0, 0.29)
}
FACES = PythonUtil.Enum('DEALER,ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN')
FACE_SPOT_POS = {
FACES.DEALER: (-1.0, 0, 0.6),
FACES.ONE: (-1.15, 0, -0.3),
FACES.TWO: (-0.96, 0, -0.61),
FACES.THREE: (-0.65, 0, -0.8),
FACES.FOUR: (0.65, 0, -0.8),
FACES.FIVE: (0.96, 0, -0.61),
FACES.SIX: (1.15, 0, -0.3)
}
FINGER_RANGES = [[-26, -16], [-3, 8], [23, 32], [52, 60]]
PLAYER_ACTIONS = PythonUtil.Enum(
'JoinGame,UnjoinGame,RejoinGame,Resign,Leave,Continue,Progress')
GAME_ACTIONS = PythonUtil.Enum('AskForContinue,NotifyOfWin,NotifyOfLoss')
CONTINUE_OPTIONS = PythonUtil.Enum('Resign,Continue,Rejoin,Leave')
GameTimeDelay = 5
RoundTimeDelay = 5
RoundTimeLimit = 90
RoundContinueWait = 10
8: PartNameStrings[3],
16: PartNameStrings[4],
32: PartNameStrings[4],
64: SimplePartNameStrings[0],
128: SimplePartNameStrings[0],
256: SimplePartNameStrings[0],
512: SimplePartNameStrings[0],
1024: PartNameStrings[10],
2048: PartNameStrings[11],
4096: PartNameStrings[12],
8192: PartNameStrings[12],
16384: PartNameStrings[14],
32768: PartNameStrings[15],
65536: PartNameStrings[15]
})
suitTypes = PythonUtil.Enum(('NoSuit', 'NoMerits', 'FullSuit'))
def getNextPart(parts, partIndex, dept):
dept = dept2deptIndex(dept)
needMask = PartsPerSuitBitmasks[dept] & PartsQueryMasks[partIndex]
haveMask = parts[dept] & PartsQueryMasks[partIndex]
nextPart = ~needMask | haveMask
nextPart = nextPart ^ nextPart + 1
nextPart = nextPart + 1 >> 1
return nextPart
def getPartName(partArray):
index = 0
for part in partArray:
def fillSlot(self, index, avId, wantBoardingShow=0):
self.notify.debug('%s.fillSlot(%s, %s, ...)' %
(self.doId, index, avId))
request = self.toonRequests.get(index)
if request:
self.cr.relatedObjectMgr.abortRequest(request)
del self.toonRequests[index]
if avId == 0:
pass
elif avId not in self.cr.doId2do:
func = PythonUtil.Functor(self.gotToon, index, avId)
self.toonRequests[index] = self.cr.relatedObjectMgr.requestObjects(
[avId], allCallback=func)
elif not self.isSetup:
self.deferredSlots.append((index, avId, wantBoardingShow))
else:
if avId == base.localAvatar.getDoId():
place = base.cr.playGame.getPlace()
if not place:
return
place.detectedElevatorCollision(self)
elevator = self.getPlaceElevator()
if elevator == None:
if place.fsm.hasStateNamed('elevator'):
place.fsm.request('elevator')
elif place.fsm.hasStateNamed('Elevator'):
place.fsm.request('Elevator')
elevator = self.getPlaceElevator()
if not elevator:
return
self.localToonOnBoard = 1
if hasattr(localAvatar,
'boardingParty') and localAvatar.boardingParty:
localAvatar.boardingParty.forceCleanupInviteePanel()
localAvatar.boardingParty.forceCleanupInviterPanels()
if hasattr(base.localAvatar, 'elevatorNotifier'):
base.localAvatar.elevatorNotifier.cleanup()
cameraTrack = Sequence()
cameraTrack.append(
Func(elevator.fsm.request, 'boarding',
[self.getElevatorModel()]))
cameraTrack.append(Func(elevator.fsm.request, 'boarded'))
toon = self.cr.doId2do[avId]
toon.stopSmooth()
if not wantBoardingShow:
toon.setZ(self.getElevatorModel(),
self.elevatorPoints[index][2])
toon.setShadowHeight(0)
if toon.isDisguised:
animInFunc = Sequence(Func(toon.suit.loop, 'walk'))
animFunc = Sequence(Func(toon.setAnimState, 'neutral', 1.0),
Func(toon.suit.loop, 'neutral'))
else:
animInFunc = Sequence(Func(toon.setAnimState, 'run', 1.0))
animFunc = Func(toon.setAnimState, 'neutral', 1.0)
toon.headsUp(self.getElevatorModel(),
apply(Point3, self.elevatorPoints[index]))
track = Sequence(animInFunc,
LerpPosInterval(toon,
TOON_BOARD_ELEVATOR_TIME * 0.75,
apply(Point3,
self.elevatorPoints[index]),
other=self.getElevatorModel()),
LerpHprInterval(toon,
TOON_BOARD_ELEVATOR_TIME * 0.25,
Point3(180, 0, 0),
other=self.getElevatorModel()),
Func(self.clearToonTrack, avId),
animFunc,
name=toon.uniqueName('fillElevator'),
autoPause=1)
if wantBoardingShow:
boardingTrack, boardingTrackType = self.getBoardingTrack(
toon, index, False)
track = Sequence(boardingTrack, track)
if avId == base.localAvatar.getDoId():
cameraWaitTime = 2.5
if boardingTrackType == BoardingGroupShow.TRACK_TYPE_RUN:
cameraWaitTime = 0.5
elif boardingTrackType == BoardingGroupShow.TRACK_TYPE_POOF:
cameraWaitTime = 1
cameraTrack = Sequence(Wait(cameraWaitTime), cameraTrack)
if self.canHideBoardingQuitBtn(avId):
track = Sequence(
Func(localAvatar.boardingParty.groupPanel.disableQuitButton
), track)
if avId == base.localAvatar.getDoId():
track = Parallel(cameraTrack, track)
track.delayDelete = DelayDelete.DelayDelete(
toon, 'Elevator.fillSlot')
self.storeToonTrack(avId, track)
track.start()
self.fillSlotTrack = track
self.boardedAvIds[avId] = None
return
PartyEditorGridBounds[0][0] +
(PartyEditorGridBounds[1][0] - PartyEditorGridBounds[0][0]) / 2.0,
PartyEditorGridBounds[1][1] +
(PartyEditorGridBounds[0][1] - PartyEditorGridBounds[1][1]) / 2.0)
PartyEditorGridSize = (18, 15)
PartyEditorGridSquareSize = (
(PartyEditorGridBounds[1][0] - PartyEditorGridBounds[0][0]) /
float(PartyEditorGridSize[0]),
(PartyEditorGridBounds[0][1] - PartyEditorGridBounds[1][1]) /
float(PartyEditorGridSize[1]))
PartyEditorGridRotateThreshold = 0.08
AvailableGridSquares = 202
TrashCanPosition = (-0.24, 0.0, -0.65)
TrashCanScale = 0.7
PartyEditorTrashBounds = ((-0.16, -0.38), (-0.05, -0.56))
ActivityRequestStatus = PythonUtil.Enum(('Joining', 'Exiting'))
InviteStatus = PythonUtil.Enum(
('NotRead', 'ReadButNotReplied', 'Accepted', 'Rejected'))
InviteTheme = PythonUtil.Enum(
('Birthday', 'GenericMale', 'GenericFemale', 'Racing', 'Valentoons',
'VictoryParty', 'Winter'))
PartyStatus = PythonUtil.Enum(('Pending', 'Cancelled', 'Finished', 'CanStart',
'Started', 'NeverStarted'))
AddPartyErrorCode = PythonUtil.Enum(
('AllOk', 'ValidationError', 'DatabaseError', 'TooManyHostedParties'))
ChangePartyFieldErrorCode = PythonUtil.Enum(
('AllOk', 'ValidationError', 'DatabaseError', 'AlreadyStarted',
'AlreadyRefunded'))
ActivityTypes = PythonUtil.Enum(
('HostInitiated', 'GuestInitiated', 'Continuous'))
PartyGateDenialReasons = PythonUtil.Enum(('Unavailable', 'Full'))
def getJumpHpr(av=av, node=self.tablecloth):
hpr = self.seats[seatIndex].getHpr(av.getParent())
angle = PythonUtil.fitDestAngle2Src(av.getH(), hpr.getX())
hpr.setX(angle)
return hpr
