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.)