def updateVisibility(self, zoneNum=None):
if zoneNum is None:
zoneNum = self.curZoneNum
if zoneNum is None:
return
if hasattr(self, 'lockVizZone'):
zoneNum = self.lockVizZone
zoneEnt = self.getEntity(zoneNum)
visibleZoneNums = list2dict([zoneNum])
visibleZoneNums.update(list2dict(zoneEnt.getVisibleZoneNums()))
if not __debug__:
if self.lastToonZone not in visibleZoneNums:
if self.lastToonZone is not None:
self.notify.warning(
'adding zoneNum %s to visibility list because toon is standing in that zone!'
% self.lastToonZone)
visibleZoneNums.update(list2dict([self.lastToonZone]))
zoneEntIds = list(self.entType2ids['zone'])
zoneEntIds.remove(LevelConstants.UberZoneEntId)
if len(zoneEntIds):
pass
vizZonesChanged = 1
addedZoneNums = []
removedZoneNums = []
allVZ = dict(visibleZoneNums)
allVZ.update(self.curVisibleZoneNums)
for vz, dummy in allVZ.items():
new = vz in visibleZoneNums
old = vz in self.curVisibleZoneNums
if new and old:
continue
if new:
addedZoneNums.append(vz)
else:
removedZoneNums.append(vz)
if not addedZoneNums and not removedZoneNums:
DistributedLevel.notify.debug('visible zone list has not changed')
vizZonesChanged = 0
else:
DistributedLevel.notify.debug('showing zones %s' % addedZoneNums)
for az in addedZoneNums:
self.showZone(az)
DistributedLevel.notify.debug('hiding zones %s' % removedZoneNums)
for rz in removedZoneNums:
self.hideZone(rz)
if vizZonesChanged or self.fForceSetZoneThisFrame:
self.setVisibility(visibleZoneNums.keys())
self.fForceSetZoneThisFrame = 0
self.curZoneNum = zoneNum
self.curVisibleZoneNums = visibleZoneNums
return
def resetVisibility(self):
self.curVisibleZoneNums = list2dict(self.zoneNums)
del self.curVisibleZoneNums[LevelConstants.UberZoneEntId]
for vz, dummy in self.curVisibleZoneNums.items():
self.showZone(vz)
self.updateVisibility()
def initVisibility(self):
self.curVisibleZoneNums = list2dict(self.zoneNums)
del self.curVisibleZoneNums[LevelConstants.UberZoneEntId]
self.curZoneNum = None
self.visChangedThisFrame = 0
self.fForceSetZoneThisFrame = 0
def handleCameraRayFloorCollision(collEntry, self=self):
name = collEntry.getIntoNode().getName()
self.notify.debug('camera floor ray collided with: %s' % name)
prefixLen = len(DistributedLevel.FloorCollPrefix)
if name[:prefixLen] == DistributedLevel.FloorCollPrefix:
try:
zoneNum = int(name[prefixLen:])
except:
DistributedLevel.notify.warning(
'Invalid zone floor collision node: %s' % name)
else:
self.camEnterZone(zoneNum)
self.accept('on-floor', handleCameraRayFloorCollision)
if not DistributedLevel.WantVisibility:
zoneNums = list(self.zoneNums)
zoneNums.remove(LevelConstants.UberZoneEntId)
self.forceSetZoneThisFrame()
self.setVisibility(zoneNums)
taskMgr.add(self.visChangeTask,
self.uniqueName(DistributedLevel.VisChangeTaskName),
priority=49)
def checkSpecIntegrity(self):
entIds = self.getGlobalEntIds()
entIds = list2dict(entIds)
for i in range(self.getNumScenarios()):
for id in self.getScenarioEntIds(i):
entIds[id] = None
if self.entTypeReg is not None:
allEntIds = entIds
for entId in allEntIds:
spec = self.getEntitySpec(entId)
entType = spec['type']
typeDesc = self.entTypeReg.getTypeDesc(entType)
attribNames = typeDesc.getAttribNames()
attribDescs = typeDesc.getAttribDescDict()
for attrib in spec.keys():
if attrib not in attribNames:
LevelSpec.notify.warning(
"entId %s (%s): unknown attrib '%s', omitting"
% (entId, spec['type'], attrib))
del spec[attrib]
for attribName in attribNames:
if not spec.has_key(attribName):
LevelSpec.notify.warning(
"entId %s (%s): missing attrib '%s'" %
(entId, spec['type'], attribName))
return
def setRequestNewEntity(self, data):
spec = self.level.levelSpec
entIds = spec.getAllEntIds()
entIdDict = list2dict(entIds)
allocRange = EditorGlobals.getEntIdAllocRange()
if not hasattr(self, 'lastAllocatedEntId'):
self.lastAllocatedEntId = allocRange[0]
idChosen = 0
while not idChosen:
for id in xrange(self.lastAllocatedEntId, allocRange[1]):
print id
if id not in entIdDict:
idChosen = 1
break
else:
if self.lastAllocatedEntId != allocRange[0]:
self.lastAllocatedEntId = allocRange[0]
else:
self.notify.error('out of entIds')
data.update({'entId': id})
self.lastAllocatedEntId = id
self.level.setAttribChange(self.entId, 'insertEntity', data)
self.level.levelSpec.doSetAttrib(self.entId, 'requestNewEntity',
None)
def announceZoneChange(self, newZoneId, oldZoneId):
DistributedPetAI.notify.debug('%s.announceZoneChange: %s->%s' %
(self.doId, oldZoneId, newZoneId))
broadcastZones = list2dict([newZoneId, oldZoneId])
PetObserve.send(
broadcastZones.keys(),
PetObserve.PetActionObserve(PetObserve.Actions.CHANGE_ZONE,
self.doId, (oldZoneId, newZoneId)))
def __handleLevelMgrCreated(self):
levelMgr = self.getEntity(LevelConstants.LevelMgrEntId)
self.geom = levelMgr.geom
self.zoneNum2node = LevelUtil.getZoneNum2Node(self.geom)
self.zoneNums = self.zoneNum2node.keys()
self.zoneNums.sort()
self.zoneNumDict = list2dict(self.zoneNums)
DistributedLevel.notify.debug('zones from model: %s' % self.zoneNums)
self.fixupLevelModel()
def __init__(self, spec=None, scenario=0):
newSpec = 0
if type(spec) is types.ModuleType:
if __dev__:
reload(spec)
self.specDict = spec.levelSpec
if __dev__:
self.setFilename(spec.__file__)
elif type(spec) is types.DictType:
self.specDict = spec
elif spec is None:
if __dev__:
newSpec = 1
self.specDict = {'globalEntities': {}, 'scenarios': [{}]}
self.entId2specDict = {}
self.entId2specDict.update(
list2dict(self.getGlobalEntIds(),
value=self.privGetGlobalEntityDict()))
for i in range(self.getNumScenarios()):
self.entId2specDict.update(
list2dict(self.getScenarioEntIds(i),
value=self.privGetScenarioEntityDict(i)))
self.setScenario(scenario)
if __dev__:
if newSpec:
import EntityTypes
import EntityTypeRegistry
etr = EntityTypeRegistry.EntityTypeRegistry(EntityTypes)
self.setEntityTypeReg(etr)
entId = LevelConstants.UberZoneEntId
self.insertEntity(entId, 'zone')
self.doSetAttrib(entId, 'name', 'UberZone')
entId = LevelConstants.LevelMgrEntId
self.insertEntity(entId, 'levelMgr')
self.doSetAttrib(entId, 'name', 'LevelMgr')
entId = LevelConstants.EditMgrEntId
self.insertEntity(entId, 'editMgr')
self.doSetAttrib(entId, 'name', 'EditMgr')
return
def announceZoneChange(self, newZoneId, oldZoneId):
DistributedPetAI.notify.debug('%s.announceZoneChange: %s->%s' % (self.doId, oldZoneId, newZoneId))
broadcastZones = list2dict([newZoneId, oldZoneId])
self.estateOwnerId = simbase.air.estateManager.getOwnerFromZone(newZoneId)
if self.estateOwnerId:
if __dev__:
pass
self.inEstate = 1
self.estateZones = simbase.air.estateManager.getEstateZones(self.estateOwnerId)
else:
self.inEstate = 0
self.estateZones = []
PetObserve.send(broadcastZones.keys(), PetObserve.PetActionObserve(PetObserve.Actions.CHANGE_ZONE, self.doId, (oldZoneId, newZoneId)))
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 _handlePhraseObserve(self, observe):
def _handleGettingFriendlyAttention(avId, self = self):
self.pet.lerpMoods({'boredom': -.85,
'restlessness': -.1,
'playfulness': 0.2,
'loneliness': -.4,
'sadness': -.1,
'fatigue': -.05,
'excitement': 0.05,
'anger': -.05})
self.updateLastInteractTime(avId)
def _handleComeHere(avId, self = self):
avatar = simbase.air.doId2do.get(avId)
if avatar:
self.pet.mover.walkToAvatar(avatar)
avatar.setHatePets(0)
def _handleFollowMe(avId, self = self):
avatar = simbase.air.doId2do.get(avId)
if avatar:
self.pet.mover.walkToAvatar(avatar)
avatar.setHatePets(0)
def _handleStay(avId, self = self):
avatar = simbase.air.doId2do.get(avId)
if avatar:
self._stay(avatar)
def _handleCriticism(avId, self = self):
ownerFactor = 0.5
if avId == self.pet.ownerId:
ownerFactor = 1.0
self.pet.lerpMoods({'affection': -.4,
'anger': 0.4,
'boredom': -.3,
'confusion': 0.05,
'fatigue': 0.2,
'playfulness': -.1,
'sadness': 0.5 * ownerFactor})
def _handleGoAway(avId, self = self):
avatar = simbase.air.doId2do.get(avId)
if avatar is not None:
if self.getFocus() == avatar:
self._wander()
return
def _handleDoTrick(trickId, avId, self = self):
looked = self.lookedAtBy(avId) or config.GetBool('pet-brain-ignore-looked-tricks', True)
avatar = simbase.air.doId2do.get(avId)
if avatar:
if looked:
if not self.pet._willDoTrick(trickId):
self.pet.trickFailLogger.addEvent(trickId)
trickId = PetTricks.Tricks.BALK
self._doTrick(trickId, avatar)
phrase = observe.getPetPhrase()
avId = observe.getAvId()
OP = PetObserve.Phrases
if phrase in list2dict([OP.COME,
OP.FOLLOW_ME,
OP.STAY,
OP.NEED_LAFF,
OP.NEED_GAGS,
OP.NEED_JB,
OP.HI,
OP.SOOTHE,
OP.PRAISE,
OP.HAPPY,
OP.QUESTION,
OP.FRIENDLY,
OP.LETS_PLAY,
OP.DO_TRICK]):
_handleGettingFriendlyAttention(avId)
if phrase == OP.COME:
_handleComeHere(avId)
if phrase == OP.FOLLOW_ME:
_handleFollowMe(avId)
if phrase == OP.STAY:
_handleStay(avId)
if phrase == OP.CRITICISM:
_handleCriticism(avId)
if phrase == OP.GO_AWAY:
_handleGoAway(avId)
if phrase == OP.DO_TRICK:
_handleDoTrick(observe.getTrickId(), avId)
