from pandac.PandaModules import * from direct.interval.IntervalGlobal import * from direct.showbase.PythonUtil import lineInfo, Functor from direct.directnotify import DirectNotifyGlobal from direct.distributed import DistributedObject from otp.level import Level from otp.level import LevelConstants from otp.level import Entity from otp.level import EditMgr from SpecImports import * from InGameEditorElements import * from toontown.cogdominium import CogdoEntityCreator import string class InGameEditorEntityBase(InGameEditorElement): def __init__(self): InGameEditorElement.__init__(self) def attribChanged(self, attrib, value): Entity.Entity.attribChanged(self, attrib, value) print 'attribChange: %s %s, %s = %s' % (self.level.getEntityType(self.entId), self.entId, attrib, repr(value)) def getTypeName(self): return self.level.getEntityType(self.entId) def privGetNamePrefix(self): return '[%s-%s] ' % (self.getTypeName(), self.entId) def privGetEntityName(self): return self.level.levelSpec.getEntitySpec(self.entId)['name'] def getName(self): return '%s%s' % (self.privGetNamePrefix(), self.privGetEntityName()) def setNewName(self, newName): prefix = self.privGetNamePrefix() if newName[:len(prefix)] == prefix: newName = newName[len(prefix):] oldName = self.privGetEntityName() if oldName != newName: self.level.setAttribEdit(self.entId, 'name', newName) def setParentEntId(self, parentEntId): self.parentEntId = parentEntId self.level.buildEntityTree() def setName(self, name): self.name = name self.level.buildEntityTree() class InGameEditorEntity(Entity.Entity, InGameEditorEntityBase): def __init__(self, level, entId): Entity.Entity.__init__(self, level, entId) InGameEditorEntityBase.__init__(self) def id(self): return self.entId def destroy(self): Entity.Entity.destroy(self) class InGameEditorEditMgr(EditMgr.EditMgr, InGameEditorEntityBase): def __init__(self, level, entId): EditMgr.EditMgr.__init__(self, level, entId) InGameEditorEntityBase.__init__(self) def destroy(self): EditMgr.EditMgr.destroy(self) class AttribModifier(Entity.Entity, InGameEditorEntityBase): notify = DirectNotifyGlobal.directNotify.newCategory('AttribModifier') def __init__(self, level, entId): Entity.Entity.__init__(self, level, entId) InGameEditorEntityBase.__init__(self) def destroy(self): Entity.Entity.destroy(self) def setValue(self, value): if len(self.typeName) == 0: AttribModifier.notify.warning('no typeName set') return entTypeReg = self.level.entTypeReg if self.typeName not in entTypeReg.getAllTypeNames(): AttribModifier.notify.warning('invalid typeName: %s' % self.typeName) return typeDesc = entTypeReg.getTypeDesc(self.typeName) if len(self.attribName) == 0: AttribModifier.notify.warning('no attribName set') return if self.attribName not in typeDesc.getAttribNames(): AttribModifier.notify.warning('invalid attribName: %s' % self.attribName) return if len(value) == 0: AttribModifier.notify.warning('no value set') def setAttrib(entId, typeName = self.typeName, attribName = self.attribName, value = eval(value), recursive = self.recursive): if typeName == self.level.getEntityType(entId): self.level.setAttribEdit(entId, attribName, value) if recursive: entity = self.level.getEntity(entId) for child in entity.getChildren(): setAttrib(child.entId) setAttrib(self.parentEntId) def getInGameEditorEntityCreatorClass(level): entCreator = level.createEntityCreator() EntCreatorClass = entCreator.__class__ class InGameEditorEntityCreator(EntCreatorClass): def __init__(self, editor): EntCreatorClass.__init__(self, editor) entTypes = self.entType2Ctor.keys() for type in entTypes: self.entType2Ctor[type] = InGameEditorEntity self.entType2Ctor['editMgr'] = InGameEditorEditMgr self.entType2Ctor['attribModifier'] = AttribModifier return InGameEditorEntityCreator class DistributedInGameEditor(DistributedObject.DistributedObject, Level.Level, InGameEditorElement): notify = DirectNotifyGlobal.directNotify.newCategory('DistributedInGameEditor') def __init__(self, cr): DistributedObject.DistributedObject.__init__(self, cr) Level.Level.__init__(self) InGameEditorElement.__init__(self) self.editorInitialized = 0 self.specModified = 0 self.undoStack = [] self.redoStack = [] self.entCreateHandlerQ = [] self.entitiesWeCreated = [] self.nodePathId2EntId = {} def generate(self): self.notify.debug('generate') DistributedObject.DistributedObject.generate(self) base.inGameEditor = self def setEditorAvId(self, editorAvId): self.editorAvId = editorAvId def setEditUsername(self, editUsername): self.editUsername = editUsername def getEditUsername(self): return self.editUsername def setLevelDoId(self, levelDoId): self.levelDoId = levelDoId self.level = base.cr.doId2do[self.levelDoId] def getLevelDoId(self): return self.levelDoId def announceGenerate(self): self.notify.debug('announceGenerate') DistributedObject.DistributedObject.announceGenerate(self) if self.editorIsLocalToon(): from otp.level import EditorGlobals EditorGlobals.assertReadyToEdit() self.notify.debug('requesting an up-to-date copy of the level spec') self.sendUpdate('requestCurrentLevelSpec') def setSpecSenderDoId(self, doId): DistributedInGameEditor.notify.debug('setSpecSenderDoId: %s' % doId) blobSender = base.cr.doId2do[doId] def setSpecBlob(specBlob, blobSender = blobSender, self = self): blobSender.sendAck() from otp.level.LevelSpec import LevelSpec curSpec = eval(specBlob) self.gotCurrentSpec(curSpec) if blobSender.isComplete(): setSpecBlob(blobSender.getBlob()) else: evtName = self.uniqueName('specDone') blobSender.setDoneEvent(evtName) self.acceptOnce(evtName, setSpecBlob) def gotCurrentSpec(self, curSpec): self.entTypeReg = self.level.getEntityTypeReg() curSpec.setEntityTypeReg(self.entTypeReg) self.axis = loader.loadModel('models/misc/xyzAxis.bam') self.axis.setColorOff() self.axis.setColorScale(1, 1, 1, 1, 1) self.initializeLevel(self.doId, curSpec, curSpec.getScenario()) entCreator = self.level.createEntityCreator() self.entTypes = entCreator.getEntityTypes() self.selectedEntity = None base.startTk() import InGameEditor doneEvent = self.uniqueName('editorDone') saveAsEvent = self.uniqueName('saveSpec') requestSaveEvent = self.uniqueName('requestSpecSave') undoEvent = self.uniqueName('undoEvent') redoEvent = self.uniqueName('redoEvent') wireframeEvent = self.uniqueName('wireframeEvent') oobeEvent = self.uniqueName('oobeEvent') csEvent = self.uniqueName('csEvent') runEvent = self.uniqueName('runEvent') texEvent = self.uniqueName('texEvent') self.editor = InGameEditor.InGameEditor(level=self, doneEvent=doneEvent, requestSaveEvent=requestSaveEvent, saveAsEvent=saveAsEvent, undoEvent=undoEvent, redoEvent=redoEvent, wireframeEvent=wireframeEvent, oobeEvent=oobeEvent, csEvent=csEvent, runEvent=runEvent, texEvent=texEvent) self.acceptOnce(doneEvent, self.doneEditing) self.accept(saveAsEvent, self.saveSpec) self.accept(requestSaveEvent, self.requestSpecSave) self.accept(undoEvent, self.doUndo) self.accept(redoEvent, self.doRedo) self.accept(wireframeEvent, self.doWireframe) self.accept(oobeEvent, self.doOobe) self.accept(csEvent, self.doCs) self.accept(runEvent, self.doRun) self.accept(texEvent, self.doTex) self.accept(self.editor.getEventMsgName('Select'), self.handleEntitySelect) self.accept(self.editor.getEventMsgName('Flash'), self.handleEntitySelect) self.editorInitialized = 1 self.buildEntityTree() return def editorIsLocalToon(self): return self.editorAvId == base.localAvatar.doId def createEntityCreator(self): return getInGameEditorEntityCreatorClass(self.level)(self) def doneEditing(self): self.notify.debug('doneEditing') if self.specModified: if self.editor.askYesNo('Save the spec on the AI?'): self.requestSpecSave() self.sendUpdate('setFinished') def disable(self): self.notify.debug('disable') if self.editorInitialized and self.editorIsLocalToon(): self.axis.removeNode() del self.axis if hasattr(self, 'entTypeReg'): del self.entTypeReg self.editorInitialized = 0 Level.Level.destroyLevel(self) if hasattr(self, 'editor'): self.editor.quit() del self.editor DistributedObject.DistributedObject.disable(self) self.ignoreAll() def getEntInstance(self, entId): return self.level.getEntity(entId) def getEntInstanceNP(self, entId): entity = self.getEntInstance(entId) if entity is None: return if isinstance(entity, NodePath): return entity if hasattr(entity, 'getNodePath'): return entity.getNodePath() return def getEntInstanceNPCopy(self, entId): np = self.getEntInstanceNP(entId) if np is None: return np stashNodeGroups = [] searches = ('**/+ActorNode', '**/+Character') for search in searches: stashNodeGroups.append(np.findAllMatches(search)) for group in stashNodeGroups: if not group.isEmpty(): group.stash() par = np.getParent() copy = np.copyTo(par) for group in stashNodeGroups: if not group.isEmpty(): group.unstash() return copy def saveSpec(self, filename): return self.levelSpec.saveToDisk(filename) def setEntityParent(self, entity, parent): parent.addChild(entity) entity._parentEntity = parent def insertEntityIntoTree(self, entId): ent = self.getEntity(entId) if entId == LevelConstants.UberZoneEntId: self.setEntityParent(ent, self) return parentEnt = self.getEntity(ent.parentEntId) if parentEnt is not None: self.setEntityParent(ent, parentEnt) return self.setEntityParent(ent, self.uberZoneEntity) return def buildEntityTree(self): self.setChildren([]) entIds = self.entities.keys() entIds.sort() for entId in entIds: ent = self.getEntity(entId) ent.setChildren([]) for entId in entIds: self.insertEntityIntoTree(entId) self.editor.refreshExplorer() def onEntityCreate(self, entId): DistributedInGameEditor.notify.debug('onEntityCreate %s' % entId) Level.Level.onEntityCreate(self, entId) entityNP = self.getEntInstanceNP(entId) if entityNP: self.nodePathId2EntId[entityNP.get_key()] = entId if not self.editorInitialized: return self.insertEntityIntoTree(entId) self.editor.refreshExplorer() if entId == self.entitiesWeCreated[0]: self.entitiesWeCreated = self.entitiesWeCreated[1:] self.editor.selectEntity(entId) def onEntityDestroy(self, entId): DistributedInGameEditor.notify.debug('onEntityDestroy %s' % entId) ent = self.getEntity(entId) if self.editorInitialized: entityNP = self.getEntInstanceNP(entId) if entityNP in self.nodePathId2EntId: del self.nodePathId2EntId[entityNP.get_key()] if ent is self.selectedEntity: self.editor.clearAttribEditPane() self.selectedEntity = None ent._parentEntity.removeChild(ent) del ent._parentEntity self.editor.refreshExplorer() Level.Level.onEntityDestroy(self, entId) return 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') return def privSendAttribEdit(self, entId, attrib, value): self.specModified = 1 valueStr = repr(value) self.notify.debug("sending edit: %s: '%s' = %s" % (entId, attrib, valueStr)) self.sendUpdate('setEdit', [entId, attrib, valueStr, self.editUsername]) def privExecActionList(self, actions): for action in actions: if callable(action): action() else: entId, attrib, value = action self.privSendAttribEdit(entId, attrib, value) def setUndoableAttribEdit(self, old2new, new2old): self.redoStack = [] self.undoStack.append((new2old, old2new)) self.privExecActionList(old2new) def setAttribEdit(self, entId, attrib, value, canUndo = 1): oldValue = eval(repr(self.levelSpec.getEntitySpec(entId)[attrib])) new2old = [(entId, attrib, oldValue)] old2new = [(entId, attrib, value)] self.setUndoableAttribEdit(old2new, new2old) if not canUndo: self.undoStack = [] def doUndo(self): if len(self.undoStack) == 0: self.editor.showWarning('Nothing left to undo') return undo = self.undoStack.pop() self.redoStack.append(undo) new2old, old2new = undo self.privExecActionList(new2old) def doRedo(self): if len(self.redoStack) == 0: self.editor.showWarning('Nothing to redo') return redo = self.redoStack.pop() self.undoStack.append(redo) new2old, old2new = redo self.privExecActionList(old2new) def doWireframe(self): messenger.send('magicWord', ['~wire']) def doOobe(self): messenger.send('magicWord', ['~oobe']) def doCs(self): messenger.send('magicWord', ['~cs']) def doRun(self): messenger.send('magicWord', ['~run']) def doTex(self): messenger.send('magicWord', ['~tex']) def insertEntity(self, entType, parentEntId = None, callback = None): if parentEntId is None: try: parentEntId = self.selectedEntity.entId except AttributeError: self.editor.showWarning('Please select a valid parent entity first.', 'error') return removeAction = (self.editMgrEntity.entId, 'removeEntity', {'entId': 'REPLACEME'}) new2old = [removeAction] def setNewEntityId(entId, self = self, action = removeAction, callback = callback): action[2]['entId'] = entId if callback: callback(entId) def setEntCreateHandler(self = self, handler = setNewEntityId): self.entCreateHandlerQ.append(handler) old2new = [setEntCreateHandler, (self.editMgrEntity.entId, 'requestNewEntity', {'entType': entType, 'parentEntId': parentEntId, 'username': self.editUsername})] self.setUndoableAttribEdit(old2new, new2old) return def setEntityCreatorUsername(self, entId, editUsername): Level.Level.setEntityCreatorUsername(self, entId, editUsername) if editUsername == self.getEditUsername(): print 'entity %s about to be created; we requested it' % entId callback = self.entCreateHandlerQ[0] del self.entCreateHandlerQ[:1] callback(entId) self.entitiesWeCreated.append(entId) def removeSelectedEntity(self): try: selectedEntId = self.selectedEntity.entId except AttributeError: self.editor.showWarning('Please select a valid entity to be removed first.', 'error') return -1 if self.getEntity(selectedEntId).getNumChildren() > 0: self.editor.showWarning('Remove children first.') return -1 self.doRemoveEntity(selectedEntId) def removeSelectedEntityTree(self): try: selectedEntId = self.selectedEntity.entId except AttributeError: self.editor.showWarning('Please select a valid entity to be removed first.', 'error') return -1 def removeEntity(entId): entity = self.getEntity(entId) for child in entity.getChildren(): removeEntity(child.entId) self.doRemoveEntity(entId) removeEntity(selectedEntId) def doRemoveEntity(self, entId): parentEntId = self.getEntity(entId)._parentEntity.entId entType = self.getEntityType(entId) if entType in self.entTypeReg.getPermanentTypeNames(): self.editor.showWarning("Cannot remove entities of type '%s'" % entType) return removeAction = (self.editMgrEntity.entId, 'removeEntity', {'entId': entId}) old2new = [removeAction] oldAttribs = [] spec = self.levelSpec.getEntitySpecCopy(entId) del spec['type'] for attrib, value in spec.items(): oldAttribs.append((attrib, value)) def setNewEntityId(entId, self = self, removeAction = removeAction, oldAttribs = oldAttribs): removeAction[2]['entId'] = entId for attrib, value in spec.items(): self.privSendAttribEdit(entId, attrib, value) def setEntCreateHandler(self = self, handler = setNewEntityId): self.entCreateHandlerQ.append(handler) new2old = [setEntCreateHandler, (self.editMgrEntity.entId, 'requestNewEntity', {'entType': self.getEntityType(entId), 'parentEntId': parentEntId, 'username': self.editUsername})] self.setUndoableAttribEdit(old2new, new2old) def makeCopyOfEntName(self, name): prefix = 'copy of ' suffix = ' (%s)' oldName = name if len(oldName) <= len(prefix): newName = prefix + oldName elif oldName[:len(prefix)] != prefix: newName = prefix + oldName else: hasSuffix = True copyNum = 2 if oldName[-1] != ')': hasSuffix = False if hasSuffix and oldName[-2] in string.digits: i = len(oldName) - 2 numString = '' while oldName[i] in string.digits: numString = oldName[i] + numString i -= 1 if oldName[i] != '(': hasSuffix = False else: i -= 1 if oldName[i] != ' ': hasSuffix = False else: print 'numString: %s' % numString copyNum = int(numString) + 1 if hasSuffix: newName = oldName[:i] + suffix % copyNum else: newName = oldName + suffix % copyNum return newName def duplicateSelectedEntity(self): try: selectedEntId = self.selectedEntity.entId parentEntId = self.selectedEntity._parentEntity.entId except AttributeError: self.editor.showWarning('Please select a valid entity to be removed first.', 'error') return if self.selectedEntity.getNumChildren() > 0: self.editor.showTodo('Cannot duplicate entity with children.') return removeAction = (self.editMgrEntity.entId, 'removeEntity', {'entId': selectedEntId}) new2old = [removeAction] copyAttribs = self.levelSpec.getEntitySpecCopy(selectedEntId) copyAttribs['comment'] = '' copyAttribs['name'] = self.makeCopyOfEntName(copyAttribs['name']) typeDesc = self.entTypeReg.getTypeDesc(copyAttribs['type']) attribDescs = typeDesc.getAttribDescDict() for attribName, attribDesc in attribDescs.items(): if attribDesc.getDatatype() == 'const': del copyAttribs[attribName] def setNewEntityId(entId, self = self, removeAction = removeAction, copyAttribs = copyAttribs): removeAction[2]['entId'] = entId for attribName, value in copyAttribs.items(): self.privSendAttribEdit(entId, attribName, value) def setEntCreateHandler(self = self, handler = setNewEntityId): self.entCreateHandlerQ.append(handler) old2new = [setEntCreateHandler, (self.editMgrEntity.entId, 'requestNewEntity', {'entType': self.getEntityType(selectedEntId), 'parentEntId': parentEntId, 'username': self.editUsername})] self.setUndoableAttribEdit(old2new, new2old) def specPrePickle(self, spec): for attribName, value in spec.items(): spec[attribName] = repr(value) return spec def specPostUnpickle(self, spec): for attribName, value in spec.items(): spec[attribName] = eval(value) return spec def handleImportEntities(self): try: selectedEntId = self.selectedEntity.entId except AttributeError: self.editor.showWarning('Please select a valid entity first.', 'error') return import tkFileDialog filename = tkFileDialog.askopenfilename(parent=self.editor.parent, defaultextension='.egroup', filetypes=[('Entity Group', '.egroup'), ('All Files', '*')]) if len(filename) == 0: return try: import pickle f = open(filename, 'r') eTree = pickle.load(f) eGroup = pickle.load(f) for entId, spec in eGroup.items(): eGroup[entId] = self.specPostUnpickle(spec) except: self.editor.showWarning("Error importing entity group from '%s'." % filename, 'error') return oldEntId2new = {} def addEntities(treeEntry, parentEntId, eGroup = eGroup): for entId, children in treeEntry.items(): spec = eGroup[entId] entType = spec['type'] del spec['type'] del spec['parentEntId'] typeDesc = self.entTypeReg.getTypeDesc(entType) for attribName, attribDesc in typeDesc.getAttribDescDict().items(): if attribDesc.getDatatype() == 'const': if attribName in spec: del spec[attribName] def handleEntityInsertComplete(newEntId, oldEntId = entId, oldEntId2new = oldEntId2new, spec = spec, treeEntry = treeEntry, addEntities = addEntities): oldEntId2new[oldEntId] = newEntId def assignAttribs(entId = newEntId, oldEntId = oldEntId, spec = spec, treeEntry = treeEntry): for attribName in spec: self.setAttribEdit(entId, attribName, spec[attribName]) addEntities(treeEntry[oldEntId], newEntId) self.acceptOnce(self.getEntityCreateEvent(newEntId), assignAttribs) self.insertEntity(entType, parentEntId=parentEntId, callback=handleEntityInsertComplete) addEntities(eTree, selectedEntId) def handleExportEntity(self): try: selectedEntId = self.selectedEntity.entId except AttributeError: self.editor.showWarning('Please select a valid entity first.', 'error') return import tkFileDialog filename = tkFileDialog.asksaveasfilename(parent=self.editor.parent, defaultextension='.egroup', filetypes=[('Entity Group', '.egroup'), ('All Files', '*')]) if len(filename) == 0: return eTree = {selectedEntId: {}} eGroup = {} eGroup[selectedEntId] = self.levelSpec.getEntitySpecCopy(selectedEntId) for entId, spec in eGroup.items(): eGroup[entId] = self.specPrePickle(spec) try: import pickle f = open(filename, 'w') pickle.dump(eTree, f) pickle.dump(eGroup, f) except: self.editor.showWarning("Error exporting entity group to '%s'." % filename, 'error') return def handleExportEntityTree(self): try: selectedEntId = self.selectedEntity.entId except AttributeError: self.editor.showWarning('Please select a valid entity first.', 'error') return import tkFileDialog filename = tkFileDialog.asksaveasfilename(parent=self.editor.parent, defaultextension='.egroup', filetypes=[('Entity Group', '.egroup'), ('All Files', '*')]) if len(filename) == 0: return eTree = {} eGroup = {} def addEntity(entId, treeEntry): treeEntry[entId] = {} eGroup[entId] = self.levelSpec.getEntitySpecCopy(entId) entity = self.getEntity(entId) for child in entity.getChildren(): addEntity(child.entId, treeEntry[entId]) addEntity(selectedEntId, eTree) for entId, spec in eGroup.items(): eGroup[entId] = self.specPrePickle(spec) try: import pickle f = open(filename, 'w') pickle.dump(eTree, f) pickle.dump(eGroup, f) except: self.editor.showWarning("Error exporting entity group to '%s'." % filename, 'error') return def moveAvToSelected(self): try: selectedEntId = self.selectedEntity.entId except AttributeError: self.editor.showWarning('Please select a valid entity first.', 'error') return entNp = self.getEntInstanceNP(selectedEntId) if entNp is None: zoneEntId = self.levelSpec.getEntityZoneEntId(selectedEntId) entNp = self.getEntInstanceNP(zoneEntId) base.localAvatar.setPos(entNp, 0, 0, 0) base.localAvatar.setHpr(entNp, 0, 0, 0) zoneNum = self.getEntityZoneEntId(selectedEntId) self.level.enterZone(zoneNum) return def requestSpecSave(self): self.privSendAttribEdit(LevelConstants.EditMgrEntId, 'requestSave', None) self.specModified = 0 return def setAttribChange(self, entId, attrib, valueStr, username): if username == self.editUsername: print 'we got our own edit back!' value = eval(valueStr) self.levelSpec.setAttribChange(entId, attrib, value, username) def getTypeName(self): return 'Level'