NonPetSphereRadius = 5.0
PetSphereRadius = 3.0
UnstickSampleWindow = 20
UnstickCollisionThreshold = int(0.5 * UnstickSampleWindow)
PriorityFleeFromAvatar = 0.6
PriorityDefault = 1.0
PriorityChaseAv = 1.0
PriorityDebugLeash = 50.0
PriorityDoTrick = 100.0
PrimaryGoalDecayDur = 60.0
PrimaryGoalScale = 1.3
HungerChaseToonScale = 1.2
FleeFromOwnerScale = 0.5
GettingAttentionGoalScale = 1.2
GettingAttentionGoalScaleDur = 7.0
AnimMoods = Enum('EXCITED, SAD, NEUTRAL')
FwdSpeed = 12.0
RotSpeed = 360.0
_HappyMult = 1.0
HappyFwdSpeed = FwdSpeed * _HappyMult
HappyRotSpeed = RotSpeed * _HappyMult
_SadMult = 0.3
SadFwdSpeed = FwdSpeed * _SadMult
SadRotSpeed = RotSpeed * _SadMult
PETCLERK_TIMER = 180
PET_MOVIE_CLEAR = 0
PET_MOVIE_START = 1
PET_MOVIE_COMPLETE = 2
PET_MOVIE_FEED = 3
PET_MOVIE_SCRATCH = 4
PET_MOVIE_CALL = 5
from direct.showbase.PythonUtil import Enum
from direct.gui.DirectGui import DirectFrame, DGG
from pandac.PandaModules import Vec2, LVecBase4f
from pandac.PandaModules import CardMaker, NodePath
from pandac.PandaModules import Texture, PNMImage
DEFAULT_MASK_RESOLUTION = 32
DEFAULT_RADIUS_RATIO = 0.05
MAP_RESOLUTION = 320
MazeRevealType = Enum(('SmoothCircle', 'HardCircle', 'Square'))
MAZE_REVEAL_TYPE = MazeRevealType.SmoothCircle
class MazeMapGui(DirectFrame):
notify = directNotify.newCategory('MazeMapGui')
def __init__(self,
mazeCollTable,
maskResolution=None,
radiusRatio=None,
bgColor=(0.8, 0.8, 0.8),
fgColor=(0.5, 0.5, 0.5, 1.0)):
DirectFrame.__init__(self,
relief=None,
state=DGG.NORMAL,
sortOrder=DGG.BACKGROUND_SORT_INDEX)
self.hide()
self._bgColor = bgColor
self._fgColor = fgColor
self._mazeCollTable = mazeCollTable
self._mazeWidth = len(self._mazeCollTable[0])
self._mazeHeight = len(self._mazeCollTable)
from direct.showbase.PythonUtil import Enum, invertDictLossless
from direct.interval.IntervalGlobal import *
import types
import random
Tricks = Enum('JUMP, BEG, PLAYDEAD, ROLLOVER, BACKFLIP, DANCE, SPEAK, BALK,')
NonHappyMinActualTrickAptitude = 0.1
NonHappyMaxActualTrickAptitude = 0.6
MinActualTrickAptitude = 0.5
MaxActualTrickAptitude = 0.97
AptitudeIncrementDidTrick = 0.0005
MaxAptitudeIncrementGotPraise = 0.0003
MaxTrickFatigue = 0.65
MinTrickFatigue = 0.1
ScId2trickId = {
21200: Tricks.JUMP,
21201: Tricks.BEG,
21202: Tricks.PLAYDEAD,
21203: Tricks.ROLLOVER,
21204: Tricks.BACKFLIP,
21205: Tricks.DANCE,
21206: Tricks.SPEAK
}
TrickId2scIds = invertDictLossless(ScId2trickId)
TrickAnims = {
Tricks.JUMP: 'jump',
Tricks.BEG: ('toBeg', 'beg', 'fromBeg'),
Tricks.PLAYDEAD: ('playDead', 'fromPlayDead'),
Tricks.ROLLOVER: 'rollover',
Tricks.BACKFLIP: 'backflip',
Tricks.DANCE: 'dance',
Tricks.SPEAK: 'speak',
from direct.fsm import FSM
from toontown.toonbase import TTLocalizer
from toontown.toonbase import ToontownGlobals
from toontown.minigame.OrthoDrive import OrthoDrive
from toontown.minigame.OrthoWalk import OrthoWalk
from toontown.parties.activityFSMs import DanceActivityFSM
from toontown.parties.PartyGlobals import ActivityIds, ActivityTypes
from toontown.parties.PartyGlobals import DancePatternToAnims, DanceAnimToName
from toontown.parties.DistributedPartyActivity import DistributedPartyActivity
from toontown.parties.PartyDanceActivityToonFSM import PartyDanceActivityToonFSM
from toontown.parties.PartyDanceActivityToonFSM import ToonDancingStates
from toontown.parties.KeyCodes import KeyCodes
from toontown.parties.KeyCodesGui import KeyCodesGui
from toontown.parties import PartyGlobals
DANCE_FLOOR_COLLISION = 'danceFloor_collision'
DanceViews = Enum(('Normal', 'Dancing', 'Isometric'))
class DistributedPartyDanceActivityBase(DistributedPartyActivity):
notify = directNotify.newCategory('DistributedPartyDanceActivity')
def __init__(self, cr, actId, dancePatternToAnims, model = 'phase_13/models/parties/danceFloor'):
DistributedPartyActivity.__init__(self, cr, actId, ActivityTypes.Continuous)
self.model = model
self.danceFloor = None
self.localToonDancing = False
self.keyCodes = None
self.gui = None
self.currentCameraMode = None
self.orthoWalk = None
self.cameraParallel = None
self.localToonDanceSequence = None
TTC = 1
DD = 2
MM = 3
GS = 4
DG = 5
BR = 6
OZ = 7
DL = 8
DefaultWantNewsPageSetting = 0
gmMagicWordList = [
'restock', 'restockUber', 'autoRestock', 'resistanceRestock',
'restockSummons', 'uberDrop', 'rich', 'maxBankMoney', 'toonUp', 'rod',
'cogPageFull', 'pinkSlips', 'Tickets', 'newSummons', 'who', 'who all'
]
NewsPageScaleAdjust = 0.85
AnimPropTypes = Enum(('Unknown', 'Hydrant', 'Mailbox', 'Trashcan'), start=-1)
EmblemTypes = Enum(('Silver', 'Gold'))
NumEmblemTypes = 2
MaxBankMoney = 50000
DefaultBankItemId = 1350
ToonAnimStates = set([
'off', 'neutral', 'victory', 'Happy', 'Sad', 'Catching', 'CatchEating',
'Sleep', 'walk', 'jumpSquat', 'jump', 'jumpAirborne', 'jumpLand', 'run',
'swim', 'swimhold', 'dive', 'cringe', 'OpenBook', 'ReadBook', 'CloseBook',
'TeleportOut', 'Died', 'TeleportedOut', 'TeleportIn', 'Emote', 'SitStart',
'Sit', 'Push', 'Squish', 'FallDown', 'GolfPuttLoop', 'GolfRotateLeft',
'GolfRotateRight', 'GolfPuttSwing', 'GolfGoodPutt', 'GolfBadPutt',
'Flattened', 'CogThiefRunning', 'ScientistJealous', 'ScientistEmcee',
'ScientistWork', 'ScientistLessWork', 'ScientistPlay'
])
AV_FLAG_REASON_TOUCH = 1
class DistributedSmoothNodeBase():
__module__ = __name__
BroadcastTypes = Enum('FULL, XYH, XY')
def __init__(self):
self.__broadcastPeriod = None
return
def generate(self):
self.cnode = CDistributedSmoothNodeBase()
self.cnode.setClockDelta(globalClockDelta)
self.d_broadcastPosHpr = None
return
def disable(self):
del self.cnode
self.stopPosHprBroadcast()
def delete(self):
pass
def b_clearSmoothing(self):
self.d_clearSmoothing()
self.clearSmoothing()
def d_clearSmoothing(self):
self.sendUpdate('clearSmoothing', [0])
def getPosHprBroadcastTaskName(self):
return 'sendPosHpr-%s' % self.doId
def setPosHprBroadcastPeriod(self, period):
self.__broadcastPeriod = period
def getPosHprBroadcastPeriod(self):
return self.__broadcastPeriod
def stopPosHprBroadcast(self):
taskMgr.remove(self.getPosHprBroadcastTaskName())
self.d_broadcastPosHpr = None
return
def posHprBroadcastStarted(self):
return self.d_broadcastPosHpr != None
def wantSmoothPosBroadcastTask(self):
return True
def startPosHprBroadcast(self, period=0.2, stagger=0, type=None):
if self.cnode == None:
self.initializeCnode()
BT = DistributedSmoothNodeBase.BroadcastTypes
if type is None:
type = BT.FULL
self.broadcastType = type
broadcastFuncs = {
BT.FULL: self.cnode.broadcastPosHprFull,
BT.XYH: self.cnode.broadcastPosHprXyh,
BT.XY: self.cnode.broadcastPosHprXy
}
self.d_broadcastPosHpr = broadcastFuncs[self.broadcastType]
taskName = self.getPosHprBroadcastTaskName()
self.cnode.initialize(self, self.dclass, self.doId)
self.setPosHprBroadcastPeriod(period)
self.b_clearSmoothing()
self.cnode.sendEverything()
taskMgr.remove(taskName)
delay = 0.0
if stagger:
delay = randFloat(period)
if self.wantSmoothPosBroadcastTask():
taskMgr.doMethodLater(self.__broadcastPeriod + delay,
self._posHprBroadcast, taskName)
return
def _posHprBroadcast(self, task=DummyTask):
self.d_broadcastPosHpr()
task.setDelay(self.__broadcastPeriod)
return Task.again
def sendCurrentPosition(self):
if self.d_broadcastPosHpr is None:
self.cnode.initialize(self, self.dclass, self.doId)
self.cnode.sendEverything()
return
from toontown.parties.activityFSMs import DanceActivityFSM
from toontown.parties.PartyGlobals import ActivityIds, ActivityTypes
from toontown.parties.PartyGlobals import DancePatternToAnims, DanceAnimToName
from toontown.parties.DistributedPartyActivity import DistributedPartyActivity
from toontown.parties.PartyDanceActivityToonFSM import PartyDanceActivityToonFSM
from toontown.parties.PartyDanceActivityToonFSM import ToonDancingStates
from toontown.parties.KeyCodes import KeyCodes
from toontown.parties.KeyCodesGui import KeyCodesGui
from toontown.parties import PartyGlobals
DANCE_FLOOR_COLLISION = "danceFloor_collision"
DanceViews = Enum((
"Normal",
"Dancing",
"Isometric",
))
class DistributedPartyDanceActivityBase(DistributedPartyActivity):
notify = directNotify.newCategory("DistributedPartyDanceActivity")
def __init__(self, cr, actId, dancePatternToAnims):
DistributedPartyActivity.__init__(self, cr, actId,
ActivityTypes.Continuous)
self.danceFloor = None
self.localToonDancing = False
self.keyCodes = None
self.gui = None
class TraitDistribution:
TraitQuality = Enum('VERY_BAD, BAD, AVERAGE, GOOD, VERY_GOOD')
TraitTypes = Enum('INCREASING, DECREASING')
Sz2MinMax = None
TraitType = None
TraitCutoffs = {
TraitTypes.INCREASING: {
TraitQuality.VERY_BAD: 0.1,
TraitQuality.BAD: 0.25,
TraitQuality.GOOD: 0.75,
TraitQuality.VERY_GOOD: 0.9
},
TraitTypes.DECREASING: {
TraitQuality.VERY_BAD: 0.9,
TraitQuality.BAD: 0.75,
TraitQuality.GOOD: 0.25,
TraitQuality.VERY_GOOD: 0.1
}
}
def __init__(self, rndFunc=gaussian):
self.rndFunc = rndFunc
if not hasattr(self.__class__, 'GlobalMinMax'):
_min = 1.0
_max = 0.0
minMax = self.Sz2MinMax
for sz in minMax:
thisMin, thisMax = minMax[sz]
_min = min(_min, thisMin)
_max = max(_max, thisMax)
self.__class__.GlobalMinMax = [_min, _max]
def getRandValue(self, szId, rng=random):
min, max = self.getMinMax(szId)
return self.rndFunc(min, max, rng)
def getHigherIsBetter(self):
return self.TraitType == TraitDistribution.TraitTypes.INCREASING
def getMinMax(self, szId):
return (self.Sz2MinMax[szId][0], self.Sz2MinMax[szId][1])
def getGlobalMinMax(self):
return (self.GlobalMinMax[0], self.GlobalMinMax[1])
def _getTraitPercent(self, traitValue):
gMin, gMax = self.getGlobalMinMax()
if traitValue < gMin:
gMin = traitValue
elif traitValue > gMax:
gMax = traitValue
return (traitValue - gMin) / (gMax - gMin)
def getPercentile(self, traitValue):
if self.TraitType is TraitDistribution.TraitTypes.INCREASING:
return self._getTraitPercent(traitValue)
else:
return 1.0 - self._getTraitPercent(traitValue)
def getQuality(self, traitValue):
TraitQuality = TraitDistribution.TraitQuality
TraitCutoffs = self.TraitCutoffs[self.TraitType]
percent = self._getTraitPercent(traitValue)
if self.TraitType is TraitDistribution.TraitTypes.INCREASING:
if percent <= TraitCutoffs[TraitQuality.VERY_BAD]:
return TraitQuality.VERY_BAD
elif percent <= TraitCutoffs[TraitQuality.BAD]:
return TraitQuality.BAD
elif percent >= TraitCutoffs[TraitQuality.VERY_GOOD]:
return TraitQuality.VERY_GOOD
elif percent >= TraitCutoffs[TraitQuality.GOOD]:
return TraitQuality.GOOD
else:
return TraitQuality.AVERAGE
elif percent <= TraitCutoffs[TraitQuality.VERY_GOOD]:
return TraitQuality.VERY_GOOD
elif percent <= TraitCutoffs[TraitQuality.GOOD]:
return TraitQuality.GOOD
elif percent >= TraitCutoffs[TraitQuality.VERY_BAD]:
return TraitQuality.VERY_BAD
elif percent >= TraitCutoffs[TraitQuality.BAD]:
return TraitQuality.BAD
else:
return TraitQuality.AVERAGE
def getExtremeness(self, traitValue):
percent = self._getTraitPercent(traitValue)
if percent < 0.5:
howExtreme = (0.5 - percent) * 2.0
else:
howExtreme = (percent - 0.5) * 2.0
return clampScalar(howExtreme, 0.0, 1.0)
class MotionAnimFSM(FSM):
BLENDAMT = 0.40000000000000002
GROUNDSTATE = Enum('OverSolid, OverWater')
ANIMSTATE = Enum('Land, Jump')
notify = directNotify.newCategory('MotionAnimFSM')
def __init__(self, av):
FSM.__init__(self, 'MotionAnimFSM')
self.av = av
self.groundState = self.GROUNDSTATE.OverSolid
self.airborneState = False
self.setAllowAirborne(True)
self.landIval = None
self.landRunIval = None
self.idleJumpIval = None
self.lastMoveSpeed = 0
self.zeroSpeedTimer = 0
self.motionFSMLag = base.config.GetBool('motionfsm-lag', 1)
self.currentSplash = None
self.splashAnims = None
self.splashAnimDelay = None
def cleanup(self):
if not self.isInTransition():
FSM.cleanup(self)
self.landIval = None
self.landRunIval = None
self.idleJumpIval = None
if hasattr(self, 'av'):
self.ignoreAll()
del self.av
def setAnimInfo(self, animInfo, reset=True):
self.fsmLock.acquire()
try:
self.animInfo = animInfo
if reset:
self.request(self.state)
finally:
self.fsmLock.release()
def trackAnimToSpeed(self, task=None):
self.fsmLock.acquire()
try:
if self.airborneState != self.av.controlManager.getIsAirborne():
self.av.b_setAirborneState(not (self.airborneState))
speeds = self.av.controlManager.getSpeeds()
if speeds:
if self.av == localAvatar:
speeds = (speeds[0], speeds[1], speeds[2],
self.av.getTrackedRotation())
self.updateAnimState(*speeds)
if task:
return task.cont
finally:
self.fsmLock.release()
def adjustAnimScale(self, state, moveSpeed, slideSpeed=0):
self.fsmLock.acquire()
try:
currAnimName = self.av.getCurrentAnim()
if (
self.av.isNpc == False or currAnimName != 'walk'
) and currAnimName != 'run' and currAnimName != 'bayonet_walk' and currAnimName != 'bayonet_run':
return None
style = self.av.style
scale = None
if hasattr(self.av, 'walkAnimScale'):
scale = self.av.walkAnimScale
if self.av is not localAvatar or style or scale:
if scale:
newScale = moveSpeed * scale
elif type(style) is not types.StringType:
style = style.getBodyShape()
animFileName = self.av.getAnimFilename(
self.av.getCurrentAnim())
animSpeedScale = PiratesGlobals.GetAnimScale(animFileName)
if animSpeedScale == None:
if currAnimName == 'walk' or currAnimName == 'bayonet_walk':
animSpeedScale = 0.24399999999999999
else:
animSpeedScale = 0.029999999999999999
newScale = moveSpeed * animSpeedScale
avScale = EnemyGlobals.getEnemyScale(self.av)
if avScale:
newScale /= avScale
newScale = max(newScale, 0.25)
if currAnimName == 'walk' or currAnimName == 'bayonet_walk':
animIdx = PiratesGlobals.WALK_INDEX
else:
animIdx = PiratesGlobals.RUN_INDEX
currPlayRate = self.av.getPlayRate(self.animInfo[animIdx][0])
if currPlayRate == None or abs(
currPlayRate - newScale) < 0.074999999999999997:
return None
if animIdx == PiratesGlobals.WALK_INDEX:
newAnimInfo = (
(self.animInfo[PiratesGlobals.STAND_INDEX][0],
self.animInfo[PiratesGlobals.STAND_INDEX][1]),
(self.animInfo[PiratesGlobals.WALK_INDEX][0],
newScale)) + self.animInfo[2:]
else:
newAnimInfo = (
(self.animInfo[PiratesGlobals.STAND_INDEX][0],
self.animInfo[PiratesGlobals.STAND_INDEX][1]),
(self.animInfo[PiratesGlobals.WALK_INDEX][0],
self.animInfo[PiratesGlobals.WALK_INDEX][1]),
(self.animInfo[PiratesGlobals.RUN_INDEX][0],
newScale)) + self.animInfo[3:]
if slideSpeed:
slideSpeed = max(slideSpeed, 0.45000000000000001)
newAnimInfo = (
(self.animInfo[PiratesGlobals.STAND_INDEX][0],
self.animInfo[PiratesGlobals.STAND_INDEX][1]),
(self.animInfo[PiratesGlobals.WALK_INDEX][0],
self.animInfo[PiratesGlobals.WALK_INDEX][1]),
(self.animInfo[PiratesGlobals.RUN_INDEX][0],
self.animInfo[PiratesGlobals.RUN_INDEX][1]),
(self.animInfo[PiratesGlobals.REVERSE_INDEX][0],
self.animInfo[PiratesGlobals.REVERSE_INDEX][1]),
(self.animInfo[PiratesGlobals.STRAFE_LEFT_INDEX][0],
slideSpeed),
(self.animInfo[PiratesGlobals.STRAFE_RIGHT_INDEX][0],
slideSpeed)) + self.animInfo[6:]
self.av.motionFSM.setAnimInfo(newAnimInfo, reset=False)
self.av.setPlayRate(newScale, self.animInfo[animIdx][0])
finally:
self.fsmLock.release()
def updateNPCAnimState(self, forwardSpeed, rotateSpeed=0, slideSpeed=0):
self.fsmLock.acquire()
try:
animScaleAdjust = False
if self.canBeAirborne and self.airborneState:
state = 'Airborne'
elif slideSpeed >= WALK_CUTOFF:
if self.av.getAnimFilename('strafe_right'):
state = 'StrafeRight'
else:
state = 'WalkForward'
elif slideSpeed <= -WALK_CUTOFF:
if self.av.getAnimFilename('strafe_left'):
state = 'StrafeLeft'
else:
state = 'WalkForward'
elif forwardSpeed >= NPC_RUN_CUTOFF:
state = 'Run'
animScaleAdjust = True
elif forwardSpeed > NPC_WALK_CUTOFF:
state = 'WalkForward'
animScaleAdjust = True
elif rotateSpeed > 0.0:
if self.av.getAnimFilename('spin_left'):
state = 'SpinLeft'
else:
state = 'WalkForward'
elif rotateSpeed < 0.0:
if self.av.getAnimFilename('spin_right'):
state = 'SpinRight'
else:
state = 'WalkForward'
else:
state = 'Idle'
zeroSpeedLimit = 0.10000000000000001
if globalClock.getFrameTime(
) - self.zeroSpeedTimer < zeroSpeedLimit and self.motionFSMLag:
if state != self.state and self.state != 'Idle':
return None
if animScaleAdjust:
self.adjustAnimScale(state, forwardSpeed, slideSpeed)
if self.state != state:
if self.isInTransition():
self.demand(state)
else:
self.request(state)
self.lastMoveSpeed = forwardSpeed
self.zeroSpeedTimer = globalClock.getFrameTime()
finally:
self.fsmLock.release()
def updateAnimState(self,
forwardSpeed,
rotateSpeed,
slideSpeed=0.0,
trackedRotation=0.0):
if self.av.getGameState() == 'Fishing':
return None
self.fsmLock.acquire()
try:
if self.canBeAirborne and self.airborneState:
state = 'Airborne'
elif forwardSpeed >= WALK_CUTOFF and slideSpeed >= WALK_CUTOFF:
state = 'StrafeRightDiag'
elif forwardSpeed >= WALK_CUTOFF and slideSpeed <= -WALK_CUTOFF:
state = 'StrafeLeftDiag'
elif forwardSpeed >= WALK_CUTOFF and trackedRotation > 1:
state = 'StrafeRightDiag'
elif forwardSpeed >= WALK_CUTOFF and trackedRotation < -1:
state = 'StrafeLeftDiag'
elif forwardSpeed >= RUN_CUTOFF:
state = 'Run'
elif forwardSpeed >= WALK_CUTOFF:
state = 'WalkForward'
self.adjustAnimScale(state, forwardSpeed)
elif forwardSpeed <= -WALK_CUTOFF and slideSpeed >= WALK_CUTOFF:
state = 'StrafeRightDiagReverse'
elif forwardSpeed <= -WALK_CUTOFF and slideSpeed <= -WALK_CUTOFF:
state = 'StrafeLeftDiagReverse'
elif forwardSpeed <= -WALK_CUTOFF:
state = 'WalkReverse'
elif slideSpeed >= WALK_CUTOFF:
state = 'StrafeRight'
elif slideSpeed <= -WALK_CUTOFF:
state = 'StrafeLeft'
elif rotateSpeed > 0.0 or trackedRotation < 0:
state = 'SpinLeft'
elif rotateSpeed < 0.0 or trackedRotation > 0:
state = 'SpinRight'
else:
state = 'Idle'
if self.state != state:
if self.av.doId < 300000000:
pass
1
if self.isInTransition():
self.demand(state)
else:
self.request(state)
if self.av.isLocal() and self.av.getGameState() == 'Emote':
messenger.send('localAvatarExitEmote')
if not self.av.isLocal() and self.av.getGameState() == 'Emote':
self.av.playEmote(self.av.emoteId)
finally:
self.fsmLock.release()
def setAllowAirborne(self, allow):
self.canBeAirborne = allow
def handleAirborneEvent(self, event):
if event == 'Jump':
self.av.b_playMotionAnim(self.ANIMSTATE.Jump)
if event == 'Land':
self.av.b_playMotionAnim(self.ANIMSTATE.Land)
handleAirborneEvent = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(handleAirborneEvent)
def playMotionAnim(self, anim, local=True):
if anim == self.ANIMSTATE.Jump:
if local:
self.jump()
else:
self.jump()
elif anim == self.ANIMSTATE.Land:
if local:
speeds = self.av.controlManager.getSpeeds()
if speeds[0] == 0.0:
self.land()
else:
self.landRun()
else:
self.land()
playMotionAnim = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(playMotionAnim)
def jump(self):
self.fsmLock.acquire()
try:
animInfo = ItemGlobals.getJumpAnimInfo(self.av.getCurrentWeapon())
if self.state == 'Idle':
startFrame = animInfo[1]
endFrame = animInfo[3]
if self.idleJumpIval:
self.idleJumpIval.finish()
self.idleJumpIval = self.av.actorInterval(
animInfo[0],
startFrame=startFrame,
endFrame=endFrame,
playRate=1.5,
blendInT=0.0,
blendOutT=self.BLENDAMT * 0.5)
self.idleJumpIval.start()
else:
startFrame = animInfo[2]
endFrame = animInfo[3]
self.av.play(animInfo[0],
fromFrame=startFrame,
toFrame=endFrame,
blendInT=self.BLENDAMT * 0.5,
blendOutT=self.BLENDAMT * 0.5)
finally:
self.fsmLock.release()
jump = report(types=['args', 'deltaStamp'], dConfigParam=['jump'])(jump)
def land(self):
self.fsmLock.acquire()
try:
animInfo = ItemGlobals.getJumpAnimInfo(self.av.getCurrentWeapon())
if self.landIval:
self.landIval.finish()
startFrame = animInfo[3]
endFrame = animInfo[4]
self.landIval = self.av.actorInterval(animInfo[0],
startFrame=startFrame,
endFrame=endFrame,
blendInT=0.0,
blendOutT=self.BLENDAMT *
0.5)
self.landIval.start()
finally:
self.fsmLock.release()
land = report(types=['args', 'deltaStamp'], dConfigParam=['jump'])(land)
def landRun(self):
self.fsmLock.acquire()
try:
if not self.landRunIval:
animInfo = ItemGlobals.getJumpAnimInfo(
self.av.getCurrentWeapon())
startFrame = animInfo[3] + 1
endFrame = startFrame + 5
self.landRunIval = self.av.actorInterval(
animInfo[0],
startFrame=startFrame,
endFrame=endFrame,
blendInT=0.0,
blendOutT=0.14999999999999999)
self.landRunIval.start()
finally:
self.fsmLock.release()
landRun = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(landRun)
def setAirborneState(self, airborneState):
self.airborneState = airborneState
setAirborneState = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(setAirborneState)
def getAirborneState(self):
return self.airborneState
getAirborneState = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(getAirborneState)
def isAirborne(self):
return self.airborneState
isAirborne = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(isAirborne)
def setGroundState(self, groundState):
self.fsmLock.acquire()
try:
if self.groundState != groundState:
self.groundState = groundState
if self.state == 'Airborne':
self.request('Airborne')
finally:
self.fsmLock.release()
setGroundState = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(setGroundState)
def startTrackAnimToSpeed(self):
taskName = self.av.taskName('trackAnimToSpeed')
taskMgr.remove(taskName)
self.trackAnimToSpeed(None)
taskMgr.add(self.trackAnimToSpeed, taskName)
def stopTrackAnimToSpeed(self):
taskName = self.av.taskName('trackAnimToSpeed')
taskMgr.remove(taskName)
def enterOff(self):
if self.landIval:
self.landIval.finish()
if self.landRunIval:
self.landRunIval.finish()
if self.idleJumpIval:
self.idleJumpIval.finish()
if self.av.isLocal():
self.ignore('jumpStart')
self.ignore('jumpLand')
self.ignore('jumpLandHard')
if self.av.isLocal():
self.av.setMovementIndex(-1)
def exitOff(self):
if self.av.isLocal():
self.accept('jumpStart', self.handleAirborneEvent, ['Jump'])
self.accept('jumpLand', self.handleAirborneEvent, ['Land'])
self.accept('jumpLandHard', self.handleAirborneEvent, ['Land'])
def enterIdle(self):
(anim, rate) = self.animInfo[PiratesGlobals.STAND_INDEX]
blendT = self.BLENDAMT * 0.5
if anim and rate:
if not hasattr(self.av, 'animIval') or not (self.av.animIval):
self.av.loop(anim, rate, blendT=blendT)
self.av.motionFSMEnterState(self.newState)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.STAND_INDEX)
self.setupSplash()
enterIdle = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(enterIdle)
def exitIdle(self):
self.av.stopLookAroundTask()
self.av.motionFSMExitState(self.oldState)
self.cleanupSplash()
def setupSplash(self):
if not IDLE_SPLASH_PLAY or not self.av.canIdleSplashEver():
return None
self.cleanupSplash()
if self.splashAnimDelay:
splashDelay = self.splashAnimDelay
else:
splashDelay = IDLE_SPLASH_DELAY
def idleOneShot(task=None):
if self.av.canIdleSplash():
if self.splashAnims:
animChoice = random.choice(self.splashAnims)
else:
animChoice = random.choice(IDLE_SPLASH_ANIMS)
self.av.setPlayRate(animChoice[1], animChoice[0])
self.av.play(animChoice[0])
if not self.av.getDuration(animChoice[0]):
pass
offset = max(5, 5)
self.currentSplash = animChoice[0]
elif not self.av.getDuration():
pass
offset = max(5, 5)
task.delayTime = random.random() * max(
0, splashDelay - offset) + offset
return task.again
delay = random.random() * splashDelay + 15
taskMgr.doMethodLater(delay, idleOneShot,
self.av.uniqueName('idleOneShot'))
def cleanupSplash(self):
taskMgr.remove(self.av.uniqueName('idleOneShot'))
self.interruptSplash()
def interruptSplash(self):
if self.currentSplash:
animCtrl = self.av.getAnimControl(self.currentSplash, 'head')
if animCtrl:
nextFrame = animCtrl.getNextFrame()
fromFrame = max(0, nextFrame - 1)
self.av.play(self.currentSplash,
fromFrame=fromFrame,
toFrame=fromFrame + 1)
self.currentSplash = None
def setupSplashAnimOverride(self, splashAnims):
self.splashAnims = splashAnims
def setupSplashAnimOverrideDelay(self, delay):
self.splashAnimDelay = delay
def enterWalkForward(self):
(anim, rate) = self.animInfo[PiratesGlobals.WALK_INDEX]
blendT = self.BLENDAMT * 0.5
if anim and rate and self.av.canMove:
self.av.loop(anim, rate, blendT=blendT)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.WALK_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
enterWalkForward = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(enterWalkForward)
def exitWalkForward(self):
pass
def enterWalkReverse(self):
(anim, rate) = self.animInfo[PiratesGlobals.REVERSE_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.REVERSE_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitWalkReverse(self):
pass
def enterSpinLeft(self):
(anim, rate) = self.animInfo[PiratesGlobals.SPIN_LEFT_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.SPIN_LEFT_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitSpinLeft(self):
pass
def enterSpinRight(self):
(anim, rate) = self.animInfo[PiratesGlobals.SPIN_RIGHT_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.SPIN_RIGHT_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitSpinRight(self):
pass
def enterStrafeRight(self):
(anim, rate) = self.animInfo[PiratesGlobals.STRAFE_RIGHT_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.STRAFE_RIGHT_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitStrafeRight(self):
pass
def enterStrafeLeft(self):
(anim, rate) = self.animInfo[PiratesGlobals.STRAFE_LEFT_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.STRAFE_LEFT_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitStrafeLeft(self):
pass
def enterStrafeRightDiag(self):
(anim, rate) = self.animInfo[PiratesGlobals.STRAFE_RIGHT_DIAG_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.STRAFE_RIGHT_DIAG_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitStrafeRightDiag(self):
pass
def enterStrafeLeftDiag(self):
(anim, rate) = self.animInfo[PiratesGlobals.STRAFE_LEFT_DIAG_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.STRAFE_LEFT_DIAG_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitStrafeLeftDiag(self):
pass
def enterStrafeRightDiagReverse(self):
(anim,
rate) = self.animInfo[PiratesGlobals.STRAFE_RIGHT_DIAG_REV_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.isLocal():
self.av.setMovementIndex(
PiratesGlobals.STRAFE_RIGHT_DIAG_REV_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitStrafeRightDiagReverse(self):
pass
def enterStrafeLeftDiagReverse(self):
(anim, rate) = self.animInfo[PiratesGlobals.STRAFE_LEFT_DIAG_REV_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.STRAFE_LEFT_DIAG_REV_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitStrafeLeftDiagReverse(self):
pass
def enterAdvance(self):
(anim, rate) = self.animInfo[PiratesGlobals.ADVANCE_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitAdvance(self):
pass
def enterRetreat(self):
(anim, rate) = self.animInfo[PiratesGlobals.RETREAT_INDEX]
if anim and rate:
self.av.loop(anim, rate, blendT=self.BLENDAMT)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitRetreat(self):
pass
def enterRun(self):
(anim, rate) = self.animInfo[PiratesGlobals.RUN_INDEX]
blendT = self.BLENDAMT * 0.5
if anim and rate and self.av.canMove:
self.av.loop(anim, rate, blendT=blendT)
if self.av.isLocal():
self.av.setMovementIndex(PiratesGlobals.RUN_INDEX)
if self.av.cameraFSM.currentCamera:
self.av.cameraFSM.currentCamera.avFaceCamera()
def exitRun(self):
pass
def enterAirborne(self):
if self.groundState == self.GROUNDSTATE.OverSolid:
idleAnim = self.animInfo[PiratesGlobals.OVER_SOLID_INDEX][0]
self.av.loop(idleAnim, blendT=0.0)
elif self.groundState == self.GROUNDSTATE.OverWater:
idleAnim = self.animInfo[PiratesGlobals.OVER_WATER_INDEX][0]
self.av.loop(idleAnim, blendT=0.0)
if self.av.isLocal():
self.av.setMovementIndex(-1)
enterAirborne = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(enterAirborne)
def exitAirborne(self):
pass
exitAirborne = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(exitAirborne)
def request(self, *args, **kwargs):
FSM.request(self, *args, **kwargs)
request = report(types=['args', 'deltaStamp'],
dConfigParam=['jump'])(request)
CashbotBossToMagnetTime = 0.2
CashbotBossFromMagnetTime = 1
CashbotBossSafeKnockImpact = 0.5
CashbotBossSafeNewImpact = 0.0
CashbotBossGoonImpact = 0.1
CashbotBossKnockoutDamage = 15
TTWakeWaterHeight = -4.79
DDWakeWaterHeight = 1.669
EstateWakeWaterHeight = -.3
OZWakeWaterHeight = -0.5
WakeRunDelta = 0.1
WakeWalkDelta = 0.2
NoItems = 0
NewItems = 1
OldItems = 2
SuitInvasionState = Enum(["Begin", "Update", "End", "Bulletin"])
Holidays = Enum([
"NoHoliday",
"February14Fireworks",
"June22Fireworks",
"July4Fireworks",
"July14Fireworks",
"October31Fireworks",
"November19Fireworks",
"NewYearsFireworks",
"ComboFireworks",
"ValentinesDay",
"IdesOfMarch",
"AprilFoolsCostumes",
"TaxDayInvasion",
"PreJuly4BigWigInvasion",
CalendarFilterShowOnlyParties = 2
# Hood identifiers
TTC = 1
DD = 2
MM = 3
GS = 4
DG = 5
BR = 6
OZ = 7
DL = 8
# NewsPage stuff
DefaultWantNewsPageSetting = 1
# GM magic words
gmMagicWordList = [
"restock", "restockUber", "autoRestock", "resistanceRestock",
"restockSummons", "uberDrop", "rich", "maxBankMoney", "toonUp", "rod",
"cogPageFull", "pinkSlips", "Tickets", "newSummons", "who", "who all"
]
NewsPageScaleAdjust = 0.85
# Prop types for the new animating props
AnimPropTypes = Enum((
"Unknown",
"Hydrant",
"Mailbox",
"Trashcan",
), start=-1)
class TiledFile(DirectObject):
notify = DirectNotifyGlobal.directNotify.newCategory('TiledFile')
map_orientations = Enum('orthogonal, isometric, staggered')
def __init__(self, filePath, fileName):
self.__filePath = filePath
self.__fileName = fileName
vfs = VirtualFileSystem.getGlobalPtr()
filename = Filename(fileName)
searchPath = DSearchPath()
if __debug__:
searchPath.appendDirectory(Filename.expandFrom('resources/%s' % filePath))
else:
searchPath.appendDirectory(Filename.expandFrom(filePath))
found = vfs.resolveFilename(filename, searchPath)
if not found:
raise TileFileIOException('Unable to locate tiled file \"%s\"; File not found on %s' % (fileName, searchPath))
self.__fileData = json.loads(vfs.readFile(filename, 1))
self.__verifyData()
self.__layers = self.__fileData['layers']
def getFilePath(self):
return self.__filePath
def getFileName(self):
return self.__fileName
def getFileData(self):
return self.__fileData
def getWidth(self):
return self.__fileData['width']
def getHeight(self):
return self.__fileData['height']
def getSize(self):
return (self.getWidth(), self.getHeight())
def getTileWidth(self):
return self.__fileData['tilewidth']
def getTileHeight(self):
return self.__fileData['tileheight']
def getTileSize(self):
return (self.getTileWidth(), self.getTileHeight())
def getOrientation(self):
return self.map_orientations.getString(self.__fileData['orientation'])
def getLayers(self):
return self.__layers
def getProperties(self):
return self.__fileData['']
def __verifyData(self):
fields = [
'width', 'height', 'tilewidth', 'tileheight', 'orientation', 'layers', 'tilesets',
'renderorder', 'properties', 'nextobjectid']
for field in fields:
if field not in self.__fileData:
raise TileFileException('Unable to verify Tiled file %s; Missing required field \"%s\"!' % (self.__fileName, field))
properties = [
'MapType'
]
def __str__(self):
arguments = {
'filePath': self.__filePath,
'sep': os.sep,
'fileName': self.__fileName,
'data': self.__fileData}
return '%(filePath)s%(sep)s%(fileName)s\n%(data)s' % arguments
"""
* Copyright (C) The Project "Nugget" Team - All Rights Reserved
* Written by Jordan Maxwell <*****@*****.**>, May 2nd, 2017
* Licensing information can found in 'LICENSE', which is part of this source code package.
"""
from direct.showbase.PythonUtil import Enum
MusicTypes = Enum('PRIMARY, SECONDARY, COMBAT')
AudioBasePath = 'audio/'
HELLO = '%shello.mp3' % AudioBasePath # TESTING AUDIO ONLY. DO NOT USE
from toontown.ai.HolidayInfoDaily import *
from toontown.ai.HolidayInfoWeekly import *
from toontown.ai.HolidayInfoMonthly import *
from toontown.ai.HolidayInfoYearly import *
from toontown.effects import FireworkManagerAI
from toontown.fishing import BingoNightHolidayAI
from toontown.suit import HolidaySuitInvasionManagerAI
from toontown.ai import BlackCatHolidayMgrAI
from toontown.toonbase import ToontownGlobals
from toontown.racing import RaceManagerAI
#################################################################
# Global Enumerations and Constants
#################################################################
Month = Enum(
'JANUARY, FEBRUARY, MARCH, APRIL, \
MAY, JUNE, JULY, AUGUST, SEPTEMBER, \
OCTOBER, NOVEMBER, DECEMBER', 1)
Day = Enum('MONDAY, TUESDAY, WEDNESDAY, THURSDAY, \
FRIDAY, SATURDAY, SUNDAY')
Holidays = {
ToontownGlobals.NEWYEARS_FIREWORKS:
HolidayInfo_Yearly(
FireworkManagerAI.FireworkManagerAI,
# PST: December 31, 07:00 - December 31, 22:00
[
(Month.DECEMBER, 31, 07, 0, 0),
# Stop them in the middle of the final hour so we do not interrupt a show in the middle
(Month.DECEMBER, 31, 22, 30, 0)
]),
class CameraMode(DirectObject.DirectObject, FSM):
Modes = Enum('NORMAL, BATTLE')
def __init__(self):
FSM.__init__(self, 'CameraMode')
self.mouseControl = False
self.mouseDelta = (0, 0)
self.lastMousePos = (0, 0)
self.origMousePos = (0, 0)
self.request('Off')
self.__inputEnabled = False
def destroy(self):
pass
def getName(self):
pass
def start(self):
if not self.isActive():
self.request('Active')
def stop(self):
if self.isActive():
self.request('Off')
def isActive(self):
return self.state == 'Active'
def enterOff(self):
pass
def exitOff(self):
pass
def enterActive(self):
self.cTravOnFloor = CollisionTraverser('CamMode.cTravOnFloor')
self.camFloorRayNode = self.attachNewNode('camFloorRayNode')
self.ccRay2 = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0)
self.ccRay2Node = CollisionNode('ccRay2Node')
self.ccRay2Node.addSolid(self.ccRay2)
self.ccRay2NodePath = self.camFloorRayNode.attachNewNode(
self.ccRay2Node)
self.ccRay2BitMask = OTPGlobals.FloorBitmask
self.ccRay2Node.setFromCollideMask(self.ccRay2BitMask)
self.ccRay2Node.setIntoCollideMask(BitMask32.allOff())
self.ccRay2MoveNodePath = hidden.attachNewNode('ccRay2MoveNode')
self.camFloorCollisionBroadcaster = CollisionHandlerFloor()
self.camFloorCollisionBroadcaster.setInPattern('on-floor')
self.camFloorCollisionBroadcaster.setOutPattern('off-floor')
self.camFloorCollisionBroadcaster.addCollider(self.ccRay2NodePath,
self.ccRay2MoveNodePath)
self.cTravOnFloor.addCollider(self.ccRay2NodePath,
self.camFloorCollisionBroadcaster)
self.enableInput()
def exitActive(self):
self.disableInput()
del self.cTravOnFloor
del self.ccRay2
del self.ccRay2Node
self.ccRay2NodePath.removeNode()
del self.ccRay2NodePath
self.ccRay2MoveNodePath.removeNode()
del self.ccRay2MoveNodePath
self.camFloorRayNode.removeNode()
del self.camFloorRayNode
def enableInput(self):
self.__inputEnabled = True
self.accept('mouse3', self.enableMouseControl)
self.accept('mouse3-up', self.disableMouseControl)
if base.mouseWatcherNode.isButtonDown(MouseButton.three()):
self.enableMouseControl()
def disableInput(self):
self.__inputEnabled = False
self.disableMouseControl()
self.ignore('mouse3')
self.ignore('mouse3-up')
def isInputEnabled(self):
return self.__inputEnabled
def enableMouseControl(self):
if hasattr(base, 'oobeMode') and base.oobeMode:
return
self.mouseControl = True
mouseData = base.win.getPointer(0)
self.origMousePos = (mouseData.getX(), mouseData.getY())
if 'localAvatar' in __builtins__:
localAvatar.guiMgr._hideCursor()
base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2)
self.lastMousePos = (base.win.getXSize() / 2, base.win.getYSize() / 2)
if self.getCurrentOrNextState() == 'Active':
self._startMouseControlTasks()
def disableMouseControl(self):
if hasattr(base, 'oobeMode') and base.oobeMode:
return
if self.mouseControl:
self.mouseControl = False
self._stopMouseControlTasks()
if 'localAvatar' in __builtins__:
localAvatar.guiMgr._showCursor()
base.win.movePointer(0, int(self.origMousePos[0]),
int(self.origMousePos[1]))
def _startMouseControlTasks(self):
if self.mouseControl:
properties = WindowProperties()
properties.setMouseMode(properties.MRelative)
base.win.requestProperties(properties)
self._startMouseReadTask()
self._startMouseUpdateTask()
def _stopMouseControlTasks(self):
properties = WindowProperties()
properties.setMouseMode(properties.MAbsolute)
base.win.requestProperties(properties)
self._stopMouseReadTask()
self._stopMouseUpdateTask()
def _startMouseReadTask(self):
self._stopMouseReadTask()
taskMgr.add(self._mouseReadTask,
'%s-MouseRead' % self._getTopNodeName(),
priority=-29)
def _mouseReadTask(self, task):
if hasattr(base, 'oobeMode') and base.oobeMode:
self.mouseDelta = (0, 0)
return task.cont
elif not base.mouseWatcherNode.hasMouse():
self.mouseDelta = (0, 0)
else:
winSize = (base.win.getXSize(), base.win.getYSize())
mouseData = base.win.getPointer(0)
if mouseData.getX() > winSize[0] or mouseData.getY() > winSize[1]:
self.mouseDelta = (0, 0)
else:
self.mouseDelta = (mouseData.getX() - self.lastMousePos[0],
mouseData.getY() - self.lastMousePos[1])
base.win.movePointer(0, winSize[0] / 2, winSize[1] / 2)
mouseData = base.win.getPointer(0)
self.lastMousePos = (mouseData.getX(), mouseData.getY())
return task.cont
def _stopMouseReadTask(self):
taskMgr.remove('%s-MouseRead' % self._getTopNodeName())
def _startMouseUpdateTask(self):
self._stopMouseUpdateTask()
taskMgr.add(self._avatarFacingTask,
'%s-AvatarFacing' % self._getTopNodeName(),
priority=23)
taskMgr.add(self._mouseUpdateTask,
'%s-MouseUpdate' % self._getTopNodeName(),
priority=40)
def _avatarFacingTask(self, task):
return task.cont
def _mouseUpdateTask(self, task):
return task.cont
def _stopMouseUpdateTask(self):
taskMgr.remove('%s-MouseUpdate' % self._getTopNodeName())
taskMgr.remove('%s-AvatarFacing' % self._getTopNodeName())
def avFaceCamera(self):
pass
# Default resolution for the mask. Should be no lower than 32.
# Larger values decrease performance.
DEFAULT_MASK_RESOLUTION = 32
# Default ratio for the reveal radius. This is essentially the percentage of
# the map that is revealed with each step.
DEFAULT_RADIUS_RATIO = 0.09
# Resolution for the map image that will be generated based on the map data.
MAP_RESOLUTION = 320
# Defines the function used to clear a portion of the mask
MazeRevealType = Enum((
"SmoothCircle",
"HardCircle",
"Square",
))
MAZE_REVEAL_TYPE = MazeRevealType.SmoothCircle
class MazeMapGui(DirectFrame):
notify = directNotify.newCategory("MazeMapGui")
def __init__(self, mazeLayout, maskResolution=None, radiusRatio=None):
"""
Constructor for a MazeMap. the mazeLayout parameter is a 2d array of
bools (or ints... maybe more depth will be added with that).
maskResolution is a value for the resolution of the mask covering the
def setColorScale(self, *args, **kwargs):
self.edgeModeNode.setColorScale(*args, **args)
self.normalModeNode.setColorScale(*args, **args)
def setScale(self, *args, **kwargs):
self.normalModeNode.setScale(*args, **args)
def setPosition(self, worldPos, *args, **kwargs):
NodePath.setPos(self, *args, **args)
if self.edgeMode:
self.edgeModeNode.setPos(*args, **args)
DecorTypes = Enum(
'Item, Billboard, Model, BillboardModel, BillboardCard, Island, Text, TextIsland, Dart, Swirl, OceanAreaText, Ship, Spline, '
)
DecorClasses = {
DecorTypes.Item: Item,
DecorTypes.Billboard: Billboard,
DecorTypes.Model: Model,
DecorTypes.BillboardModel: BillboardModel,
DecorTypes.BillboardCard: BillboardCard,
DecorTypes.Island: Island,
DecorTypes.Text: Text,
DecorTypes.TextIsland: TextIsland,
DecorTypes.Dart: Dart,
DecorTypes.Swirl: Swirl,
DecorTypes.OceanAreaText: OceanAreaText,
DecorTypes.Ship: Ship,
DecorTypes.Spline: Spline
class DistributedSmoothNodeBase:
"""common base class for DistributedSmoothNode and DistributedSmoothNodeAI
"""
BroadcastTypes = Enum('FULL, XYH, XY')
def __init__(self):
self.__broadcastPeriod = None
def generate(self):
self.cnode = CDistributedSmoothNodeBase()
self.cnode.setClockDelta(globalClockDelta)
self.d_broadcastPosHpr = None
def disable(self):
del self.cnode
# make sure our task is gone
self.stopPosHprBroadcast()
def delete(self):
pass
def b_clearSmoothing(self):
self.d_clearSmoothing()
self.clearSmoothing()
def d_clearSmoothing(self):
self.sendUpdate("clearSmoothing", [0])
### posHprBroadcast ###
def getPosHprBroadcastTaskName(self):
# presumably, we have a doId at this point
return "sendPosHpr-%s" % self.doId
def setPosHprBroadcastPeriod(self, period):
# call this at any time to change the delay between broadcasts
self.__broadcastPeriod = period
def getPosHprBroadcastPeriod(self):
# query the current delay between broadcasts
return self.__broadcastPeriod
def stopPosHprBroadcast(self):
taskMgr.remove(self.getPosHprBroadcastTaskName())
# Delete this callback because it maintains a reference to self
self.d_broadcastPosHpr = None
def posHprBroadcastStarted(self):
return self.d_broadcastPosHpr != None
def wantSmoothPosBroadcastTask(self):
return True
def startPosHprBroadcast(self, period=.2, stagger=0, type=None):
if self.cnode == None:
self.initializeCnode()
BT = DistributedSmoothNodeBase.BroadcastTypes
if type is None:
type = BT.FULL
# set the broadcast type
self.broadcastType = type
broadcastFuncs = {
BT.FULL: self.cnode.broadcastPosHprFull,
BT.XYH: self.cnode.broadcastPosHprXyh,
BT.XY: self.cnode.broadcastPosHprXy,
}
# this comment is here so it will show up in a grep for 'def d_broadcastPosHpr'
self.d_broadcastPosHpr = broadcastFuncs[self.broadcastType]
# Set stagger to non-zero to randomly delay the initial task execution
# over 'period' seconds, to spread out task processing over time
# when a large number of SmoothNodes are created simultaneously.
taskName = self.getPosHprBroadcastTaskName()
# Set up telemetry optimization variables
self.cnode.initialize(self, self.dclass, self.doId)
self.setPosHprBroadcastPeriod(period)
# Broadcast our initial position
self.b_clearSmoothing()
self.cnode.sendEverything()
# remove any old tasks
taskMgr.remove(taskName)
# spawn the new task
delay = 0.
if stagger:
delay = randFloat(period)
if self.wantSmoothPosBroadcastTask():
taskMgr.doMethodLater(self.__broadcastPeriod + delay,
self._posHprBroadcast, taskName)
def _posHprBroadcast(self, task=DummyTask):
# TODO: we explicitly stagger the initial task timing in
# startPosHprBroadcast; we should at least make an effort to keep
# this task accurately aligned with its period and starting time.
self.d_broadcastPosHpr()
task.setDelay(self.__broadcastPeriod)
return Task.again
def sendCurrentPosition(self):
# if we're not currently broadcasting, make sure things are set up
if self.d_broadcastPosHpr is None:
self.cnode.initialize(self, self.dclass, self.doId)
self.cnode.sendEverything()
# GM magic words
gmMagicWordList = [
"restock", "restockUber", "autoRestock",
"resistanceRestock", "restockSummons",
"uberDrop", "rich", "maxBankMoney",
"toonUp", "rod", "cogPageFull", "pinkSlips",
"Tickets", "newSummons", "who", "who all"
]
NewsPageScaleAdjust = 0.85
# Prop types for the new animating props
AnimPropTypes = Enum(("Unknown",
"Hydrant",
"Mailbox",
"Trashcan",
),
start = -1
)
# Cogdo Reward Emblems
EmblemTypes = Enum(("Silver", "Gold"))
NumEmblemTypes = 2
# Max Bank Update
DefaultMaxBankMoney = 12000
DefaultBankItemId = 1350
# Toon Animation States
ToonAnimStates = set([
"off",
def getEventName(zoneId):
return 'PetObserve-%s' % zoneId
def send(zoneIds, petObserve):
if petObserve.isValid():
if type(zoneIds) not in (types.ListType, types.TupleType):
zoneIds = [zoneIds]
for zoneId in zoneIds:
messenger.send(getEventName(zoneId), [petObserve])
Phrases = Enum(
'HI, BYE, YES, NO, SOOTHE, PRAISE, CRITICISM, HAPPY,SAD, ANGRY, HURRY, QUESTION, FRIENDLY, LETS_PLAY,COME, FOLLOW_ME, STAY, NEED_LAFF, NEED_GAGS, NEED_JB,GO_AWAY, DO_TRICK,'
)
Actions = Enum(
'FEED, SCRATCH,ATTENDED_START, ATTENDED_STOP,ATTENDING_START, ATTENDING_STOP,CHANGE_ZONE, LOGOUT,GARDEN'
)
class PetObserve:
def isValid(self):
return 1
def isForgettable(self):
return 0
def _influence(self, petBrain):
petBrain._handleGenericObserve(self)
class TraitDistribution:
# TraitDistributions describe a distribution from which to generate a
# trait value. Traits are in [0..1]
# these are classifications for pet traits
TraitQuality = Enum('VERY_BAD, BAD, AVERAGE, GOOD, VERY_GOOD')
# INCREASING means higher value is better
TraitTypes = Enum('INCREASING, DECREASING')
# subclasses should set this to a table of szId: (min, max)
Sz2MinMax = None
# subclasses should set this to a TraitTypes value
TraitType = None
TraitCutoffs = {
TraitTypes.INCREASING: {TraitQuality.VERY_BAD: .10,
TraitQuality.BAD: .25,
TraitQuality.GOOD: .75,
TraitQuality.VERY_GOOD: .90},
TraitTypes.DECREASING: {TraitQuality.VERY_BAD: .90,
TraitQuality.BAD: .75,
TraitQuality.GOOD: .25,
TraitQuality.VERY_GOOD: .10},
}
def __init__(self, rndFunc=gaussian):
# randFunc should return in 0..1
self.rndFunc = rndFunc
# calculate the lowest and highest trait values
if not hasattr(self.__class__, 'GlobalMinMax'):
# don't cover up global min and max funcs
_min = 1.; _max = 0.
minMax = self.Sz2MinMax
for sz in minMax:
thisMin, thisMax = minMax[sz]
_min = min(_min, thisMin)
_max = max(_max, thisMax)
self.__class__.GlobalMinMax = [_min, _max]
def getRandValue(self, szId, rng=random):
min, max = self.getMinMax(szId)
return self.rndFunc(min, max, rng)
def getHigherIsBetter(self):
return self.TraitType == TraitDistribution.TraitTypes.INCREASING
def getMinMax(self, szId):
# returns min, max trait values for a given safezone
return self.Sz2MinMax[szId][0], self.Sz2MinMax[szId][1]
def getGlobalMinMax(self):
# returns overall min and max trait values for all safezones
return self.GlobalMinMax[0], self.GlobalMinMax[1]
def _getTraitPercent(self, traitValue):
# internal function, returns value in [0,1] representing the
# value in relation to the distribution's min and max values
gMin, gMax = self.getGlobalMinMax()
# if the min and max have been pulled in tighter since this
# pet was stored in the database, fudge the numbers
if traitValue < gMin:
gMin = traitValue
elif traitValue > gMax:
gMax = traitValue
return (traitValue - gMin) / (gMax - gMin)
def getPercentile(self, traitValue):
# returns value in [0,1] representing the value in relation
# to the distribution's range. 0 is least desirable, 1
# is most desirable.
if self.TraitType is TraitDistribution.TraitTypes.INCREASING:
return self._getTraitPercent(traitValue)
else:
return 1. - self._getTraitPercent(traitValue)
def getQuality(self, traitValue):
# returns TraitQuality enum given a particular trait value
TraitQuality = TraitDistribution.TraitQuality
TraitCutoffs = self.TraitCutoffs[self.TraitType]
percent = self._getTraitPercent(traitValue)
if self.TraitType is TraitDistribution.TraitTypes.INCREASING:
if percent <= TraitCutoffs[TraitQuality.VERY_BAD]:
return TraitQuality.VERY_BAD
elif percent <= TraitCutoffs[TraitQuality.BAD]:
return TraitQuality.BAD
elif percent >= TraitCutoffs[TraitQuality.VERY_GOOD]:
return TraitQuality.VERY_GOOD
elif percent >= TraitCutoffs[TraitQuality.GOOD]:
return TraitQuality.GOOD
else:
return TraitQuality.AVERAGE
else:
if percent <= TraitCutoffs[TraitQuality.VERY_GOOD]:
return TraitQuality.VERY_GOOD
elif percent <= TraitCutoffs[TraitQuality.GOOD]:
return TraitQuality.GOOD
elif percent >= TraitCutoffs[TraitQuality.VERY_BAD]:
return TraitQuality.VERY_BAD
elif percent >= TraitCutoffs[TraitQuality.BAD]:
return TraitQuality.BAD
else:
return TraitQuality.AVERAGE
def getExtremeness(self, traitValue):
# returns 'extremeness' value in [0..1] for a particular trait value
percent = self._getTraitPercent(traitValue)
if percent < .5:
howExtreme = (.5 - percent) * 2.
else:
howExtreme = (percent - .5) * 2.
return clampScalar(howExtreme, 0., 1.)
