def enterInteract(self):
PetGoal.notify.debug('enterInteract')
if self._chaseAvInInteractMode():
self.accept(
self.brain.getObserveEventAttendingAvStop(self.avatar.doId),
Functor(self.request, 'Chase'))
self.startInteract()
def _removeCurrentShardInterest(self, callback):
if self.old_setzone_interest_handle is None:
self.notify.warning('removeToontownShardInterest: no shard interest open')
callback()
return
self.acceptOnce(ToontownClientRepository.ClearInterestDoneEvent, Functor(self._tcrRemoveUberZoneInterest, callback))
self._removeEmulatedSetZone(ToontownClientRepository.ClearInterestDoneEvent)
return
def switchCamPos(self, viewIndex, colEntry=None):
av = base.localAvatar
prevView = av.cameraIndex
self.currentCamPos = viewIndex
av.accept('exit' + self.views[viewIndex][0],
Functor(self.prevCamPos, prevView))
self.notify.info('auto-switching to camera position %s' % viewIndex)
av.setCameraSettings(self.views[viewIndex][1])
def __init__(self, level):
EntityCreatorAI.EntityCreatorAI.__init__(self, level)
# create short aliases for EntityCreatorAI create funcs
cDE = EntityCreatorAI.createDistributedEntity
cLE = EntityCreatorAI.createLocalEntity
nothing = EntityCreatorAI.nothing
self.privRegisterTypes({
'levelMgr':
Functor(cLE, CogdoLevelMgrAI),
'cogdoBoardroomGameSettings':
Functor(
cLE,
Functor(self._createCogdoSettings,
CogdoBoardroomGameConsts.Settings)),
'cogdoCraneGameSettings':
Functor(
cLE,
Functor(self._createCogdoSettings,
CogdoCraneGameConsts.Settings)),
'cogdoCraneCogSettings':
Functor(
cLE,
Functor(self._createCogdoSettings,
CogdoCraneGameConsts.CogSettings)),
})
def handleEntitySelect(self, entity):
self.selectedEntity = entity
if hasattr(self, 'identifyIval'):
self.identifyIval.finish()
if entity is self:
self.editor.clearAttribEditPane()
else:
entityNP = self.getEntInstanceNP(entity.entId)
if entityNP is not None:
dur = float(0.5)
oColor = entityNP.getColorScale()
flashIval = Sequence(
Func(Functor(entityNP.setColorScale, 1, 0, 0, 1)),
WaitInterval(dur / 3),
Func(Functor(entityNP.setColorScale, 0, 1, 0, 1)),
WaitInterval(dur / 3),
Func(Functor(entityNP.setColorScale, 0, 0, 1, 1)),
WaitInterval(dur / 3),
Func(
Functor(entityNP.setColorScale, oColor[0], oColor[1],
oColor[2], oColor[3])))
boundIval = Sequence(Func(entityNP.showBounds),
WaitInterval(dur * 0.5),
Func(entityNP.hideBounds))
entCp = self.getEntInstanceNPCopy(entity.entId)
entCp.setRenderModeWireframe()
entCp.setTextureOff(1)
wireIval = Sequence(
Func(Functor(entCp.setColor, 1, 0, 0, 1, 1)),
WaitInterval(dur / 3),
Func(Functor(entCp.setColor, 0, 1, 0, 1, 1)),
WaitInterval(dur / 3),
Func(Functor(entCp.setColor, 0, 0, 1, 1, 1)),
WaitInterval(dur / 3), Func(entCp.removeNode))
self.identifyIval = Parallel(flashIval, boundIval, wireIval)
def putAxis(self=self, entityNP=entityNP):
self.axis.reparentTo(entityNP)
self.axis.setPos(0, 0, 0)
self.axis.setHpr(0, 0, 0)
def takeAxis(self=self):
self.axis.reparentTo(hidden)
self.identifyIval = Sequence(
Func(putAxis),
Parallel(self.identifyIval, WaitInterval(1000.5)),
Func(takeAxis))
self.identifyIval.start()
self.editor.updateAttribEditPane(entity.entId, self.levelSpec,
self.entTypeReg)
entType = self.getEntityType(entity.entId)
menu = self.editor.menuBar.component('Entity-menu')
index = menu.index('Remove Selected Entity')
if entType in self.entTypeReg.getPermanentTypeNames():
menu.entryconfigure(index, state='disabled')
else:
menu.entryconfigure(index, state='normal')
def handleToonEnterEstate(self, avId, ownerId, zoneId):
assert (PetManagerAI.notify.debug('toon going to estate: %s %s %s' %
(avId, ownerId, zoneId)))
toon = simbase.air.doId2do[avId]
# is the toon already in the estate zone?
if toon.zoneId == zoneId:
self._onToonArriveInEstate(avId, ownerId, zoneId)
else:
self.accept(toon.getLogicalZoneChangeEvent(),
Functor(self._toonChangedZone, avId))
self.acceptOnce(self.air.getAvatarExitEvent(avId),
Functor(self._toonDidntMakeItToEstate, avId))
self._toonsPendingEstateArrival[avId] = (ownerId, zoneId)
self._pendingToonEvents[avId] = [
toon.getLogicalZoneChangeEvent(),
self.air.getAvatarExitEvent(avId),
]
def addMessage(self, message, autoDestroy = 1):
self.msgStack.append(message)
self.msgStack.sort()
index = self._getMessageIndex(message)
message.setPos(self._getSlotPos(index))
message.createIval(self['fadeLerpTime'], Functor(self.removeMessage, message, autoDestroy)).start()
self._adjustStack(index + 1)
self._startSlideIval()
self.popupSfx.play()
def run():
tt = base.cr.loginInterface
tester = TTTester()
# pick a random login and password
# chances are that this account name has not been used before.
name = getRandomString('login')
pwd = getRandomString('password')
# try logging in with an invalid account name
tester.runTest(Functor(tt.authorize, name, pwd),
SHOULD_FAIL,
"login attempt with probably-invalid "
"username %s succeeded" % name)
# try getting account data for an invalid account name
tester.runTest(Functor(tt.getAccountData, name, pwd),
SHOULD_FAIL,
"account data 'get' with probably-invalid "
"username %s succeeded" % name)
# create the account
data = {
'dobYear' : 1978,
'dobMonth' : 3,
'dobDay' : 14,
}
accountCreated = tester.runTest(
Functor(tt.createAccount, name, pwd, data),
SHOULD_SUCCEED,
"account creation failed")
if accountCreated:
# try logging in with a valid account name
tester.runTest(Functor(tt.authorize, name, pwd),
SHOULD_SUCCEED,
"login attempt failed")
# try getting the account data
tester.runTest(Functor(tt.getAccountData, name, pwd),
SHOULD_SUCCEED,
"failed to get account data")
tester.printResults()
def addEvent(self, eventName):
if self._completed:
self.notify.error("addEvent('%s') called on completed EventGroup '%s'" % (eventName, self.getName()))
if eventName in self._subEvents:
self.notify.error("addEvent('%s'): event already in EventGroup '%s'" % (eventName, self.getName()))
self._subEvents.add(eventName)
self.acceptOnce(eventName, Functor(self._subEventComplete, eventName))
return eventName
def __init__(self, level):
EntityCreatorBase.EntityCreatorBase.__init__(self, level)
cLE = createLocalEntity
self.privRegisterTypes({
'attribModifier': nothing,
'ambientSound': nothing,
'collisionSolid': nothing,
'cutScene': nothing,
'entityGroup': nothing,
'entrancePoint': nothing,
'levelMgr': Functor(cLE, LevelMgrAI.LevelMgrAI),
'locator': nothing,
'logicGate': Functor(cLE, LogicGate.LogicGate),
'model': nothing,
'nodepath': nothing,
'path': nothing,
'propSpinner': nothing,
'visibilityExtender': nothing,
'zone': Functor(cLE, ZoneEntityAI.ZoneEntityAI)
})
def __init__(self, name, postNames, callback, removeNames=None):
self.notify.debug('__init__: %s, %s, %s' % (name, postNames, callback))
if removeNames is None:
removeNames = []
self.name = name
self.postNames = makeList(postNames)
self.removeNames = makeList(removeNames)
self.callback = callback
self.waitingOn = set()
for name in self.postNames:
if not bboard.has(name):
eventName = bboard.getEvent(name)
self.waitingOn.add(eventName)
self.acceptOnce(eventName, Functor(self._handleEvent, eventName))
for name in self.removeNames:
if bboard.has(name):
eventName = bboard.getRemoveEvent(name)
self.waitingOn.add(eventName)
self.acceptOnce(eventName, Functor(self._handleEvent, eventName))
self._checkDone()
def _listenForToonEnterEstate(self, avId, ownerId, zoneId):
#self.notify.debug('_listenForToonEnterEstate(avId=%s, ownerId=%s, zoneId=%s)' % (avId, ownerId, zoneId))
if avId in self.avId2pendingEnter:
self.notify.warning(
'_listenForToonEnterEstate(avId=%s, ownerId=%s, zoneId=%s): %s already in avId2pendingEnter. overwriting'
% (avId, ownerId, zoneId, avId))
self.avId2pendingEnter[avId] = (ownerId, zoneId)
self.accept(
DistributedObjectAI.DistributedObjectAI.
staticGetLogicalZoneChangeEvent(avId),
Functor(self._toonChangedZone, avId))
def __handleDelete(self, t_or_b):
if t_or_b == ClosetGlobals.SHIRT:
item = TTLocalizer.ClosetShirt
elif self.toon.style.torso[1] == 'd':
item = TTLocalizer.ClosetSkirt
else:
item = TTLocalizer.ClosetShorts
self.verify = TTDialog.TTGlobalDialog(doneEvent='verifyDone', message=TTLocalizer.ClosetVerifyDelete % item, style=TTDialog.TwoChoice)
self.verify.show()
self.accept('verifyDone', Functor(self.__handleVerifyDelete, t_or_b))
messenger.send('wakeup')
def initializeLevel(self, levelSpec):
self.startTime = globalClock.getRealTime()
self.startTimestamp = globalClockDelta.localToNetworkTime(self.startTime, bits=32)
lol = list(zip([1] * levelSpec.getNumScenarios(), list(range(levelSpec.getNumScenarios()))))
scenarioIndex = weightedChoice(lol)
Level.Level.initializeLevel(self, self.doId, levelSpec, scenarioIndex)
if __dev__:
self.accept(self.editMgrEntity.getSpecSaveEvent(), self.saveSpec)
for avId in self.avIdList:
self.acceptOnce(self.air.getAvatarExitEvent(avId), Functor(self.handleAvatarDisconnect, avId))
self.allToonsGoneBarrier = self.beginBarrier('allToonsGone', self.avIdList, 3 * 24 * 60 * 60, self.allToonsGone)
def __init__(self, factory):
self.factory = factory
# add a few useful views for the factory
av = base.localAvatar
self.currentCamPos = None
self.views = [
[
"signatureRoomView",
# Look down at the signature room from the button balcony
(
Point3(0., -14.8419799805, 13.212685585), # pos
Point3(0., -13.9563484192, 12.749215126), # fwd
Point3(0.0, 1.5, 15.75), # up
Point3(0.0, 1.5, -3.9375), # down
1),
["localToonLeftBattle"], # regenerate view on battle done
],
[
"lookoutTrigger",
# Look at the whole signature room from the lookout balcony
(
Point3(0, -17.7, 28.8), # pos
Point3(0, 10, 0), # fwd
Point3(0.0, 1.5, 15.75), # up
Point3(0.0, 1.5, -3.9375), # down
1),
[],
],
[
"moleFieldView",
# Look at a bigger portion of mole field
(
Point3(0, -17.7, 28.8), # pos
Point3(0, 10, 0), # fwd
Point3(0.0, 1.5, 15.75), # up
Point3(0.0, 1.5, -3.9375), # down
1),
[],
],
]
camHeight = av.getClampedAvatarHeight()
for i in range(len(self.views)):
camPos = self.views[i][1]
av.auxCameraPositions.append(camPos)
factory.accept("enter" + self.views[i][0],
Functor(self.switchCamPos, i))
# camera can also switch specified events
for msg in self.views[i][2]:
factory.accept(msg, self.checkCamPos)
def addEvent(self, eventName):
""" Adds a new event to the list of sub-events that we're waiting on.
Returns the name of the event. """
if self._completed:
self.notify.error('addEvent(\'%s\') called on completed EventGroup \'%s\'' % (
eventName, self.getName()))
if eventName in self._subEvents:
self.notify.error('addEvent(\'%s\'): event already in EventGroup \'%s\'' % (
eventName, self.getName()))
self._subEvents.add(eventName)
self.acceptOnce(eventName, Functor(self._subEventComplete, eventName))
return eventName
def switchCamPos(self, viewIndex, colEntry=None):
# switch to old view when done
av = base.localAvatar
prevView = av.cameraIndex
self.currentCamPos = viewIndex
# listen for exit event
av.accept("exit" + self.views[viewIndex][0],
Functor(self.prevCamPos, prevView))
self.notify.info('auto-switching to camera position %s' % viewIndex)
av.setCameraSettings(self.views[viewIndex][1])
def handleZoneCreated(self, entId):
zoneEnt = self.level.getEntity(entId)
# register the zone's info in the tables
self.level.zoneNum2zoneId[zoneEnt.entId] = zoneEnt.getZoneId()
# TODO: we should delay this until all zone entities have been
# created on level init
self.privCreateSortedZoneIdList()
# listen for the zone's destruction
self.accept(self.level.getEntityDestroyEvent(entId),
Functor(self.handleZoneDestroy, entId))
def addMultiChoiceWidget(self, levelSpec, entSpec, entId, attribName, params):
frame = Frame(self.pageOneFrame.interior(), relief=GROOVE, borderwidth=2)
label = Label(frame, text=attribName, width=15, anchor=W, justify=LEFT)
label.pack(side=LEFT, expand=0)
valueDict = params.get('valueDict', {})
self.cbDict[attribName] = list2dict(entSpec[attribName], value=1)
checkbuttonDict = {}
base.cbButtons = []
base.checkbuttonDict = checkbuttonDict
for choice in params.get('choiceSet', []):
trueValue = valueDict.get(choice, choice)
cbVar = IntVar()
cbVar.set(trueValue in self.cbDict[attribName])
checkbuttonDict[trueValue] = cbVar
def cbCommand(var, trueValue=trueValue):
vd = self.cbDict[attribName]
print vd
if var.get():
print 'got it', trueValue, vd
vd[trueValue] = 1
else:
print 'not it', trueValue, vd
if trueValue in vd:
del vd[trueValue]
value = vd.keys()
print 'SENDING', value
self.level.setAttribEdit(entId, attribName, value)
if type(choice) is types.StringType:
labelStr = choice
else:
labelStr = `choice`
func = Functor(cbCommand, cbVar)
choiceButton = Checkbutton(frame, text=labelStr, variable=cbVar, command=lambda : func())
choiceButton.pack(side=LEFT, expand=0)
base.cbButtons.append(choiceButton)
frame.pack(fill=X, expand=1)
self.attribWidgets.append(frame)
def setCheckbuttonVar(attributeValueList):
print 'COMING BACK', attributeValueList
for attributeValue, cb in checkbuttonDict.items():
if attributeValue in attributeValueList:
cb.set(1)
else:
cb.set(0)
self.curEntWidgets[attribName] = setCheckbuttonVar
def __handleDelete(self, which):
abortDeletion = False
if which == ToonDNA.HAT:
item = TTLocalizer.TrunkHat
elif which == ToonDNA.GLASSES:
item = TTLocalizer.TrunkGlasses
elif which == ToonDNA.BACKPACK:
item = TTLocalizer.TrunkBackpack
else:
item = TTLocalizer.TrunkShoes
self.verify = TTDialog.TTGlobalDialog(doneEvent='verifyDone', message=TTLocalizer.ClosetVerifyDelete % item, style=TTDialog.TwoChoice)
self.verify.show()
self.accept('verifyDone', Functor(self.__handleVerifyDelete, which))
messenger.send('wakeup')
def queryReadyForStageThree(self):
allReady = True
for fortId in self.fortIds:
fortObj = base.cr.doId2do.get(fortId)
if fortObj == None or not fortObj.readyToGo():
allReady = False
if allReady:
self.sendUpdate('readyForStageThree')
else:
self.stageThreeDelayedCall = DelayedCall(Functor(
self.queryReadyForStageThree),
delay=0.1)
return
def __init__(self, name, postNames, callback):
self.notify.debug('__init__: %s, %s, %s' % (name, postNames, callback))
self.name = name
if type(postNames) == type(''):
postNames = [postNames]
self.postNames = postNames
self.callback = callback
self.waitingOn = {}
for name in postNames:
if not bboard.has(name):
eventName = bboard.getEventName(name)
self.acceptOnce(eventName, Functor(self.handlePost, eventName))
self.waitingOn[eventName] = None
self.checkDone()
def enterChase(self):
PetGoal.notify.debug('enterChase')
if self.brain.lookingAt(self.avatar.doId):
def goToInteract(task=None, self=self):
self.request('Interact')
return Task.done
taskMgr.doMethodLater(0.0001, goToInteract,
self.transitionDoLaterName)
else:
self.accept(
self.brain.getObserveEventAttendingAvStart(self.avatar.doId),
Functor(self.request, 'Interact'))
self.brain._chase(self.avatar)
def enterChase(self):
PetGoal.notify.debug('enterChase')
if self.brain.lookingAt(self.avatar.doId):
# we can't immediately transition to the Interact state
# spawn a doLater
def goToInteract(task=None, self=self):
self.request('Interact')
return Task.done
taskMgr.doMethodLater(.0001, goToInteract,
self.transitionDoLaterName)
else:
# chase until we are looking at them
self.accept(
self.brain.getObserveEventAttendingAvStart(self.avatar.doId),
Functor(self.request, 'Interact'))
self.brain._chase(self.avatar)
def enterPurchase(self):
PurchaseBase.enterPurchase(self)
self.convertingVotesToBeansLabel.hide()
self.rewardDoubledJellybeanLabel.hide()
self.bg.reparentTo(render)
base.setBackgroundColor(0.78, 0.65, 0.53)
self.accept('purchaseStateChange', self.__handleStateChange)
self.playAgain.reparentTo(self.toon.inventory.purchaseFrame)
self.backToPlayground.reparentTo(self.toon.inventory.purchaseFrame)
self.pointDisplay.reparentTo(self.toon.inventory.purchaseFrame)
self.statusLabel.reparentTo(self.toon.inventory.purchaseFrame)
for headFrame in self.headFrames:
headFrame[1].show()
headFrame[1].reparentTo(self.toon.inventory.purchaseFrame)
if base.cr.periodTimerExpired:
base.cr.loginFSM.request('periodTimeout')
return
if not self.tutorialMode:
if not config.GetBool('disable-purchase-timer', 0):
self.timer.show()
self.timer.countdown(self.remain, self.__timerExpired)
if config.GetBool('metagame-disable-playAgain', 0):
if self.metagameRound > -1:
self.disablePlayAgain()
else:
self.timer.hide()
self.disablePlayAgain()
self.accept(
'disableGagPanel',
Functor(self.toon.inventory.setActivateMode,
'gagTutDisabled',
gagTutMode=1))
self.accept('disableBackToPlayground',
self.disableBackToPlayground)
self.accept('enableGagPanel', self.handleEnableGagPanel)
self.accept('enableBackToPlayground', self.enableBackToPlayground)
for avId, headFrame in self.headFrames:
if avId != self.newbieId:
headFrame.hide()
messenger.send('gagScreenIsUp')
if base.autoPlayAgain or self.doMetagamePlayAgain():
base.transitions.fadeOut(0)
self.__handlePlayAgain()
def handleZoneCreated(self, entId):
zoneEnt = self.level.getEntity(entId)
# register the zone's info in the tables
assert zoneEnt.entId not in self.zoneNums
self.zoneNums.append(zoneEnt.entId)
# we can assume that we have a complete list of network zoneIds in
# self.level.zoneIds. As each zone entity is created, set up
# as if we have all of the zone entities. This allows dynamic
# zone entity creation and deletion during editing.
# TODO: we should delay this until all zone entities have been
# created on level init
self.privAssignZoneIds()
# listen for the zone's destruction
self.accept(self.level.getEntityDestroyEvent(entId),
Functor(self.handleZoneDestroy, entId))
def _analyzeResults(self, sessionId):
# do the analysis in a task 1) to separate the processing from the profiled frame,
# and 2) to get the processing to show up in a named task instead of in the taskMgr
self._id2task[sessionId] = taskMgr.add(
Functor(self._doAnalysis, sessionId),
'FrameProfilerAnalysis-%s' % sessionId)
def getDropIval(self, x, y, dropObjName, num):
objType = Name2DropObjectType[dropObjName]
dropNode = hidden.attachNewNode('catchDropNode%s' % num)
dropNode.setPos(x, y, 0)
shadow = self.dropShadow.copyTo(dropNode)
shadow.setZ(0.2)
shadow.setColor(1, 1, 1, 1)
object = self.getObjModel(dropObjName)
object.reparentTo(dropNode)
if dropObjName in ['watermelon', 'anvil']:
objH = object.getH()
absDelta = {'watermelon': 12, 'anvil': 15}[dropObjName]
delta = (self.randomNumGen.random() * 2.0 - 1.0) * absDelta
newH = objH + delta
else:
newH = self.randomNumGen.random() * 360.0
object.setH(newH)
sphereName = 'FallObj%s' % num
radius = self.ObjRadius
if objType.good:
radius *= lerp(1.0, 1.3, self.getDifficulty())
collSphere = CollisionSphere(0, 0, 0, radius)
collSphere.setTangible(0)
collNode = CollisionNode(sphereName)
collNode.setCollideMask(ToontownGlobals.CatchGameBitmask)
collNode.addSolid(collSphere)
collNodePath = object.attachNewNode(collNode)
collNodePath.hide()
if self.ShowObjSpheres:
collNodePath.show()
catchEventName = 'ltCatch' + sphereName
def eatCollEntry(forward, collEntry):
forward()
self.accept(catchEventName,
Functor(eatCollEntry, Functor(self.__handleCatch, num)))
def cleanup(self=self,
dropNode=dropNode,
num=num,
event=catchEventName):
self.ignore(event)
dropNode.removeNode()
duration = objType.fallDuration
onscreenDuration = objType.onscreenDuration
dropHeight = self.MinOffscreenHeight
targetShadowScale = 0.3
if self.TrickShadows:
intermedScale = targetShadowScale * (self.OffscreenTime /
self.BaselineDropDuration)
shadowScaleIval = Sequence(
LerpScaleInterval(shadow,
self.OffscreenTime,
intermedScale,
startScale=0))
shadowScaleIval.append(
LerpScaleInterval(shadow,
duration - self.OffscreenTime,
targetShadowScale,
startScale=intermedScale))
else:
shadowScaleIval = LerpScaleInterval(shadow,
duration,
targetShadowScale,
startScale=0)
targetShadowAlpha = 0.4
shadowAlphaIval = LerpColorScaleInterval(
shadow,
self.OffscreenTime,
Point4(1, 1, 1, targetShadowAlpha),
startColorScale=Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
if self.UseGravity:
def setObjPos(t, objType=objType, object=object):
z = objType.trajectory.calcZ(t)
object.setZ(z)
setObjPos(0)
dropIval = LerpFunctionInterval(setObjPos,
fromData=0,
toData=onscreenDuration,
duration=onscreenDuration)
else:
startPos = Point3(0, 0, self.MinOffscreenHeight)
object.setPos(startPos)
dropIval = LerpPosInterval(object,
onscreenDuration,
Point3(0, 0, 0),
startPos=startPos,
blendType='easeIn')
ival = Sequence(Func(Functor(dropNode.reparentTo, render)),
Parallel(
Sequence(WaitInterval(self.OffscreenTime),
dropIval), shadowIval),
Func(cleanup),
name='drop%s' % num)
landSound = None
if objType == Name2DropObjectType['anvil']:
landSound = self.sndAnvilLand
if landSound:
ival.append(SoundInterval(landSound))
return ival
def _do__call__(self, *args, **kargs):
self.saveStatus()
self.result = Functor._do__call__(self, *args, **kargs)
self.postCall()
return self.result
def handleZoneCreated(self, entId):
zoneEnt = self.level.getEntity(entId)
self.level.zoneNum2zoneId[zoneEnt.entId] = zoneEnt.getZoneId()
self.privCreateSortedZoneIdList()
self.accept(self.level.getEntityDestroyEvent(entId), Functor(self.handleZoneDestroy, entId))
