def CreateNode(self, point, memObject):
xNoise = Global.Randint(-Global.ELNodeAddNoise, Global.ELNodeAddNoise)
yNoise = Global.Randint(-Global.ELNodeAddNoise, Global.ELNodeAddNoise)
x = float(point.x + xNoise)
y = float(point.y + yNoise)
while not self.area.IsInside(Point(x, y)):
xNoise = Global.Randint(-Global.ELNodeAddNoise,
Global.ELNodeAddNoise)
yNoise = Global.Randint(-Global.ELNodeAddNoise,
Global.ELNodeAddNoise)
x = float(point.x + xNoise)
y = float(point.y + yNoise)
newNode = EnergyLayerNode(self, x, y, self.nodeIndex)
self.nodeIndex = self.nodeIndex + 1
self.nodes.append(newNode)
if Global.CreatePlaces:
place = self.GetPlaceForNode(newNode)
place.nodes.append(newNode)
newNode.place = place
memObject.AddLinkToNode(newNode)
memObject.IntenseToNode(newNode, Global.MemObjIntenseToNewNode)
self.stepELNodesCreated = self.stepELNodesCreated + 1
return newNode
def LookForObject(self, memoryPhantom):
memObject = memoryPhantom.object
map = Global.Map
visibleObjects = map.GetVisibleObjects(self.agent)
foundObj = None
for obj in visibleObjects:
if obj == memObject.object:
foundObj = obj
if foundObj == None:
self.spaceMap.ObjectNotFound(memoryPhantom.object)
self.memoryArea.RemovePhantom(memoryPhantom)
memoryPhantom.MemoryObjectNotFound()
return None
#else: found:
phantom = self.GetPhantomForObj(foundObj)
if phantom != None:
phantom.Update(foundObj)
phantom.memoryPhantom = memoryPhantom
self.spaceMap.ObjectNoticedAgain(foundObj)
Global.Log("PF: RE-adding phantom(lookFor) for object " +
foundObj.ToString())
else:
phantom = Phantom(foundObj, memoryPhantom)
self.environmentPhantoms.append(phantom)
self.processArea.PhantomAddedForMemoryPhantom(
phantom, memoryPhantom)
self.spaceMap.ObjectFound(foundObj)
Global.Log("PF: Adding phantom(lookFor) for object " +
foundObj.ToString())
return foundObj
def SaveHeatMap(self):
for n in self.nodes:
nStr = "%d;%d;%.4f" % (int(n.x), int(n.y), n.usage)
Global.LogData("elnodeheatmap", nStr)
for n in self.nodes:
nStr = "%d;%d;%.4f" % (int(n.x), int(n.y), n.AGamount)
Global.LogData("elnodeheatmapag", nStr)
def updateMemoryObjectLocation(self, memObject):
links = memObject.linkToNodes
x = 0
y = 0
if 0 == len(links):
return memObject
sumIntensity = 0
for link in links:
x += (link.node.x * link.intensity)
y += (link.node.y * link.intensity)
sumIntensity += link.intensity
x = x / sumIntensity
y = y / sumIntensity
p = Point(x, y)
if not self.map.IsInside(
p): #this should not happen, quick hack - go closer to memObj
hit = self.map.CanMoveEx(memObject, p.x, p.y)
if hit.hit:
p = hit
else:
Global.Log(
"Programmer.Error: SpaceMap: not inside but canMove-not-hit"
)
memObject.x = p.x
memObject.y = p.y
step = Global.GetStep()
error = self.map.DistanceObjs(p, memObject.object)
errorStr = '%.2f' % error
trained = memObject.object.trainHistory
line = str(step) + ";" + str(
trained) + ";" + errorStr + ";" + memObject.object.IdStr()
Global.LogData("rememberinfo", line)
return memObject
def stopSimulation(self):
Global.Log("Stoping simulation...")
self.exitLocks()
Global.Reset()
self.agent = None
self.mapRenderer.Clear()
self.mapRenderer = None
self.lock = None
def ChooseProcessForIntention(self, emotion, intention, parentProcess):
processes = intention.processes
if parentProcess != None:
processes = Global.SetDifference(processes, parentProcess.failedProcesses)
if len(processes) == 0:
return None
if intention.name == "Want": #for Want intention the order of process matters
return processes[0]
else:
return Global.Choice(processes)
def StepUpdate(self):
for ep in self.energyPoints:
ep.StepUpdate(self.getNodesAround(ep, Global.ELGravityRange))
for node in self.nodes:
node.StepUpdate(
self.getNodesAround(node, Global.ELAntigravityRange))
for node in self.nodes:
node.StepUpdateMove()
if Global.CreatePlaces:
placesToDelete = []
for place in self.places:
place.CalculateAG()
if place.slowAGamount < Global.PlacesAGMin * (place.level - 1):
placesToDelete.append(place)
continue
if place.AGamount > Global.PlacesAGNeeded * (2**(place.level) -
1):
self.createPlaces(place)
if place.parent != None:
place.UpdateLocation()
place.CalculateRange()
place.SaveStatus()
for place in placesToDelete:
place.Delete()
for node in self.nodes:
p = self.GetPlaceForNode(node)
if p != node.place:
node.place.nodes.remove(node)
node.place = p
p.nodes.append(node)
for ep in self.energyPointsToDelete:
self.energyPoints.remove(ep)
self.energyPointsToDelete = []
self.forgetEnergy = self.forgetEnergy + Global.ELForgetNodeRate
cost = self.GetNodeDeleteCost()
chanceForget = 100 * float(self.forgetEnergy - cost) / cost
diceRoll = Global.DiceRoll()
if diceRoll < chanceForget and len(self.nodes) > 0:
node = Global.Choice(self.nodes)
self.forgetEnergy = self.forgetEnergy - (
cost * log(max(2, node.usage), 2))
self.DeleteNode(node)
Global.LogData("nc", self.Status())
def CreateMap(self):
areaArea = self.area.GetArea()
nodeCount = areaArea / Global.ELDensity**2
self.desiredNodeCount = nodeCount * 2
self.minimalDesiredNodeCount = self.desiredNodeCount / 5
self.maximalDesiredNodeCount = self.desiredNodeCount
x = self.area.points[0].x
y = self.area.points[0].y
if Global.CreatePlaces:
rootPlace = Place(self, self.placeIndex, self.area.width / 2 + x,
self.area.height / 2 + y)
rootPlace.range = max(x + self.area.width,
y + self.area.height) * sqrt(2) / 2
rootPlace.range = ceil(rootPlace.range)
rootPlace.startRange = rootPlace.range
self.places.append(rootPlace)
if Global.ELCreateNoise == -1: #completely random distribution of nodes
while len(self.nodes) < nodeCount:
x = float(Global.Randint(0, self.area.width - 1))
y = float(Global.Randint(0, self.area.height - 1))
if self.area.IsInside(Point(x, y)):
node = EnergyLayerNode(self, x, y, self.nodeIndex)
self.nodeIndex = self.nodeIndex + 1
self.nodes.append(node)
if Global.CreatePlaces:
node.place = rootPlace
rootPlace.nodes.append(node)
else:
xCount = self.area.width / Global.ELDensity
yCount = self.area.height / Global.ELDensity
density = Global.ELDensity
for y in range(yCount):
for x in range(xCount):
xNoise = Global.Randint(-Global.ELCreateNoise,
Global.ELCreateNoise)
yNoise = Global.Randint(-Global.ELCreateNoise,
Global.ELCreateNoise)
xx = float(x * density + density / 2 + xNoise)
yy = float(y * density + density / 2 + yNoise)
if self.area.IsInside(Point(xx, yy)):
node = EnergyLayerNode(self, xx, yy, self.nodeIndex)
self.nodeIndex = self.nodeIndex + 1
self.nodes.append(node)
if Global.CreatePlaces:
node.place = rootPlace
rootPlace.nodes.append(node)
def NoticeObjects(self, visibleObjects, actProcess):
self.perceptionFilter.ProcessObjects(visibleObjects, actProcess)
phantomsToSpaceMap = {}
for rObj in visibleObjects:
if rObj.curAttractivity == 0: continue
phantom = self.GetPhantomForObj(rObj)
if phantom != None:
phantom.Update(rObj)
phantomsToSpaceMap[phantom] = "ObjectNoticedAgain"
else:
memPhantom = self.memoryArea.GetPhantomForObject(rObj)
if memPhantom != None and self.processArea.LookingForPhantom(
memPhantom):
phantom = Phantom(rObj, memPhantom)
self.environmentPhantoms.append(phantom)
#self.processArea.PhantomAddedForMemoryPhantom(phantom, memPhantom) - later
phantomsToSpaceMap[phantom] = "ObjectFound"
Global.Log("PF: Adding phantom for object " +
rObj.ToString() + " instead of " +
memPhantom.ToString())
else:
phantom = Phantom(rObj)
self.environmentPhantoms.append(phantom)
#self.processArea.PhantomAdded(phantom) - later
phantomsToSpaceMap[phantom] = "ObjectNoticed"
Global.Log("PF: Adding phantom for object " +
rObj.ToString())
#phantoms updated, truncate to PF.Size
phantoms = self.environmentPhantoms
phantoms.sort(lambda b, a: cmp(a.habituation, b.habituation))
phantomsToDelete = phantoms[Global.PFSize:]
for phantomToDelete in phantomsToDelete:
self.environmentPhantoms.remove(phantomToDelete)
phantomToDelete.DeletedOrLost()
Global.Log("PF: removing(over PF.size) phantom for object " +
phantomToDelete.object.ToString())
for phantom in self.environmentPhantoms:
if phantom not in phantomsToSpaceMap:
#happens when agent changes viewCones and object is not in normal VCs (was added by explore VCs) - ignore
continue
if phantomsToSpaceMap[phantom] == "ObjectNoticedAgain":
self.spaceMap.ObjectNoticedAgain(phantom.object)
elif phantomsToSpaceMap[phantom] == "ObjectFound":
self.processArea.PhantomAddedForMemoryPhantom(
phantom, phantom.memoryPhantom)
self.spaceMap.ObjectFound(phantom.object)
elif phantomsToSpaceMap[phantom] == "ObjectNoticed":
self.processArea.PhantomAdded(phantom)
self.spaceMap.ObjectNoticed(phantom.object)
def StepUpdateMove(self, normalStep=True):
massCoef = 1.0 / max(1, self.usage)
dx = self.stepDiffX * massCoef
dy = self.stepDiffY * massCoef
distToMove2 = dx * dx + dy * dy
maxDif = Global.MaxELNodeMove
if distToMove2 > (maxDif * maxDif):
distToMove = sqrt(distToMove2)
coef = maxDif / distToMove
dx = dx * coef
dy = dy * coef
newX = self.x + dx
newY = self.y + dy
hit = self.area.CanMoveEx(self, newX, newY)
if hit.hit:
newX = hit.x
newY = hit.y
ldx = newX - self.x
ldy = newY - self.y
distToMove2 = ldx * ldx + ldy * ldy
if distToMove2 < 0.0001:
newX = self.x
newY = self.y
if normalStep and Global.SaveELNodesStatus:
ldx = newX - self.x
ldy = newY - self.y
distToMove = sqrt(ldx * ldx + ldy * ldy)
if self.area.IsInside(Point(newX, newY)):
self.x = newX
self.y = newY
self.stepDiffX = self.stepDiffY = 0
if normalStep:
self.usage -= Global.ELNodeUsageFadeOut
if self.usage < 0: self.usage = 0
self.AGamount -= Global.ELAGFadeOut
if normalStep and Global.SaveELNodesStatus:
status = str(Global.GetStep()) + ";" + str(
self.index) + ";%.4f;%.4f;%.4f" % (distToMove, self.usage,
self.AGamount)
Global.LogData("elnode-status", status)
def GetAction(self, emotion):
if self.processArea.HasNoIntention():
self.ChooseIntention()
#agent has intention (in self.PA.actInt)
excIntention = self.processArea.GetActIntention()
excProcess = self.processArea.GetActProcess()
#what is active - I or P ?
if excIntention.parentExcProcess == excProcess:
#if I under P -> we have active I and need some process to do it (or this is HL intention)
process = self.ChooseProcessForIntention(emotion, excIntention.intention, excIntention.parentExcProcess)
if process == None:
self.processArea.TerminateIntentionFalse(emotion)
#impossible to finish this intention -> terminate int and parent process, try to choose another process in parent intention
return self.GetAction(emotion)
excProcess = self.processArea.ActivateProcess(emotion, process, excIntention, excIntention.parentExcProcess)
else:
#if P under I -> we have already selected process for this intention previously, go on
process = excProcess.process
#now we have intention and under it process to do
#process atomic?
if process.intentions != []:
#process is not atomic -> choose first not completed sub-intention
intention = Global.SetFirstDifference(process.intentions, excProcess.completedIntentions)
self.processArea.ActivateIntention(intention, excProcess)
return self.GetAction(emotion) #go deeper for atomic process
else:
# process is atomic
return self.GetAtomicAction(emotion, excProcess)
def TerminateProcess(self, emotion, successful=True):
if self.actualProcess == None:
self.actualIntention = None #there is no process left - HL intention finnished
return
self.actualProcess.TerminateProcess(successful)
#commented in original: self.episodicMemory.StoreProcess(self.actualProcess, emotion)
if not successful:
# actual process went wrong, next step AS will select another in parent intention
self.actualProcess = self.actualProcess.parent
else:
# actual process finnished, parent intention as well
self.actualProcess = self.actualProcess.parent
if self.actualProcess != None:
notFinishedIntentions = Global.SetDifference(self.actualProcess.process.intentions, self.actualProcess.completedIntentions)
if len(notFinishedIntentions) == 0:
self.TerminateProcess(True)
else:
# this would be otherwise called in AS next step via AS.ChooseProcessForIntention but randomly
self.ActivateIntention(notFinishedIntentions[0], self.actualProcess)
else:
#there is no process left - HL intention finnished
self.actualIntention = None
def SetOwnerProcess(self, process):
if self.ownerProcess != None:
Global.Log(
"Programmer.Error: Phantom with owner process set again: " +
self.object.ToString())
self.ownerProcess = process
process.resources.append(self)
def PhantomAddedForMemoryPhantom(self, phantom, memoryPhantom):
phantom.affordance = memoryPhantom.affordance
realProcess = self.actualBasicProcess
if realProcess != memoryPhantom.ownerProcess:
Global.Log("Programmer.Error: PA.PhantomAddedForMemoryPhantom relinking memPhantom for in-active process")
phantom.ownerProcess = realProcess
realProcess.resources.append(phantom)
realProcess.resources.remove(memoryPhantom)
def RemovePhantom(self, memoryPhantom):
if memoryPhantom == None: return
if memoryPhantom not in self.memoryPhantoms:
Global.Log(
"Programmer.Error: MemoryArea.RemovePhantom not in MA: " +
memoryPhantom.object.ToString())
return
self.memoryPhantoms.remove(memoryPhantom)
def Status(self):
strObjs = str(len(self.area.objects))
s = str(Global.GetStep()) + ';' + str(len(self.nodes)) + ";" + str(
self.stepEPCreated) + ";" + str(
self.stepELNodesCreated) + ";" + str(
self.desiredNodeCount) + ";" + strObjs
self.stepEPCreated = 0
self.stepELNodesCreated = 0
return s
def SetAllToRegardingAffs(self, rObjs, action, coef):
sources = action.sources
sourcesCount = len(sources)
for rObj in rObjs:
affs = []
for aff in rObj.type.affordances:
if aff in sources:
affs.append(aff)
rObj.curAttractivity = Global.WeakCoef(
coef * float(len(affs)) / sourcesCount, 2) * rObj.attractivity
def UpdatePhantomsBecauseOfMove(self, agent):
map = Global.Map
lostPhantoms = []
for phantom in self.environmentPhantoms:
if not map.IsObjectVisible(agent, phantom.object):
lostPhantoms.append(phantom)
for phantom in lostPhantoms:
self.environmentPhantoms.remove(phantom)
phantom.DeletedOrLost()
Global.Log("PF: removing(lost) phantom for object " +
phantom.object.ToString())
def startSimulation(self, configName):
if not os.path.exists("../../exs/"): os.makedirs("../../exs/")
dirList = os.listdir("../../exs/")
for fname in dirList:
os.remove("../../exs/" + fname)
Global.LogStart("../../exs/")
Global.Log("Starting new simulation and world for Config: " + configName)
seed(Global.RandomSeeds[0])
config = Config.Get(configName)
world = World( config )
Global.World = world
self.agent = Agent(config)
world.SetAgent(self.agent)
self.mapRenderer = MapRenderer(self.wxCanvas, Global.Map, self.agent, self)
self.lock = Lock()
self.lock.acquire()
self.playbackLock = Lock()
th = Thread(None, self.simulationThread, name="simulationThread")
th.start()
def Update(self, action):
habituatedPhantoms = []
for phantom in self.environmentPhantoms:
#if self.processArea.IsPhantomUsedNow(phantom): continue - not enough
if phantom.ownerProcess == None or (
not phantom.ownerProcess.IsInProgress()):
if phantom.Habituate(action.duration):
habituatedPhantoms.append(phantom)
for habituatedPhantom in habituatedPhantoms:
self.environmentPhantoms.remove(habituatedPhantom)
habituatedPhantom.DeletedOrLost()
Global.Log("PF: removing(habituated) phantom for object " +
habituatedPhantom.object.ToString())
def UseObjectPhantoms(self, excProcess):
for phantom in excProcess.resources:
if phantom.GetType() != "e":
Global.Log(
"Programmer.Error: using memory phantom and memory object: "
+ phantom.ToString())
continue
self.spaceMap.ObjectUsed(phantom.object)
map = Global.Map
usedSources = [
] #excProcess.process.usedSources Future: object.amount TBD.
for usedSource in usedSources:
for phantom in excProcess.resources:
if usedSource == phantom.affordance:
if map.UseObject(
excProcess,
phantom.object): #true means object is used Up
self.spaceMap.ObjectUsedUp(phantom.object)
self.environmentPhantoms.remove(phantom)
Global.Log("PF: removing(used) phantom for object " +
phantom.object.ToString())
def RenderState(self, world):
self.mapRenderer.RenderObjectVisibility()
self.mapRenderer.RenderSpaceMap()
self.mapRenderer.RenderAgent(world.agent)
#self.mapRenderer.RenderObjects() - only for dynamic worlds
if Global.RenderVisibilityHistory:
self.mapRenderer.RenderVisibilityHistory()
else:
self.mapRenderer.HideVisibilityHistory()
self.wxCanvas.delete("infotxt")
txt = "Step: " + str(world.step).zfill(6) + "\nTime: " + Global.TimeToHumanFormat(True)
self.txtTime = self.wxCanvas.create_text(1080, 5, text=txt, width=200, anchor=NW, tags="infotxt")
strXY = "%.4f,%.4f" % (self.agent.x, self.agent.y)
txt = "Agent: " + strXY
nc = len(world.agent.intelligence.spaceMap.Layer.nodes)
txt = txt + "\nEnergyLayer.nodeCount: " + str(nc)
self.txtAgentInfo = self.wxCanvas.create_text(1300, 5, text=txt, width=200, anchor=NW, tags="infotxt")
pa = self.agent.intelligence.processArea
txt = "ProcessArea:\n" + "\n".join(self.agent.paText)
self.txtPA = self.wxCanvas.create_text(1050, 50, text=txt, width=200, anchor=NW, tags="infotxt")
ma = self.agent.intelligence.memoryArea
txt = "MemoryArea:\n "
for phantom in ma.memoryPhantoms:
txt = txt + phantom.ToString() + "\n "
self.txtMA = self.wxCanvas.create_text(1050, 200, text=txt, width=400, anchor=NW, tags="infotxt")
pf = self.agent.intelligence.perceptionField
txt = "PerceptionField:\n "
for phantom in pf.environmentPhantoms:
txt = txt + phantom.ToString() + "\n "
self.txtPF = self.wxCanvas.create_text(1050, 300, text=txt, width=400, anchor=NW, tags="infotxt")
txt = "Log:\n "
for line in Global.logLines:
txt = txt + line + "\n "
self.txtLog = self.wxCanvas.create_text(1050, 550, text=txt, width=450, anchor=NW, tags="infotxt")
Global.LogData("nc", world.agent.intelligence.spaceMap.Layer.Status())
def runOneSimulation(self, savePath, configName, randomSeed):
savePath = savePath + str(randomSeed) + "-" + configName + "/"
os.makedirs(savePath)
Global.LogStart(savePath)
Global.Log("Starting new simulation and world for Config: " + configName)
try:
seed(randomSeed)
config = Config.Get(configName)
world = World(config)
Global.World = world
self.agent = Agent(config)
world.SetAgent(self.agent)
self.mapRenderer = MapRenderer(self.wxCanvas, Global.Map, self.agent, self, False)
self.currentTestIndex = self.currentTestIndex + 1
self.mapRenderer.RenderProgress(self, configName)
self.mapRenderer.RenderProgressInTest(world.step, Global.MaxTestSteps)
time.sleep(0.1)
elayer = world.agent.intelligence.spaceMap.Layer
while world.step < Global.MaxTestSteps:
world.Step()
self.mapRenderer.RenderToFile(world, savePath + "PIL" + str(world.step).zfill(6) + ".png")
self.mapRenderer.RenderProgressInTest(world.step, Global.MaxTestSteps)
world.SendAgentOut()
while world.step < Global.MaxTestSteps + Global.MaxTestStepAfter:
world.Step()
self.mapRenderer.RenderToFile(world, savePath + "PIL" + str(world.step).zfill(6) + ".png")
self.mapRenderer.RenderProgressInTest(world.step, Global.MaxTestSteps)
if Global.CalculateVisibilityHistory:
self.mapRenderer.RenderToFile(world, savePath + "visibilityheatmap.png", ["vh"])
self.mapRenderer.RenderToFile(world, savePath + "visibilityobjectheatmap.png", ["ovh"])
map = Global.Map
map.SaveHeatMap()
self.agent.intelligence.spaceMap.Layer.SaveHeatMap()
except:
Global.Log("FATAL ERROR occured: ")
ss = traceback.format_exc()
Global.Log(ss)
time.sleep(1)
raise
finally:
Global.Log("Stoping simulation...")
Global.LogEnd()
Global.Reset()
self.agent = None
self.mapRenderer.Clear()
self.mapRenderer = None
def ProcessObjects(self, rObjs, action):
name = action.process.name
if name == "Remember":
self.SetAllTo(rObjs, 0)
elif name == "LookForObject":
self.SetAllTo(rObjs, 0)
elif name == "MoveToPartial":
self.SetAllTo(rObjs, 1)
elif name == "Explore":
self.SetAllToRegardingAffs(rObjs, action, 1)
elif name == "ExecuteReal":
self.SetAllToRegardingAffs(rObjs, action, 0.5)
else:
Global.Log(
"Programmer.Error: PerceptionFilter process name unknown: " +
name)
def StepUpdate(self, nodesAround):
cost = self.layer.GetNodeCreateCost()
chanceNew = 100 * float(self.energy - cost) / cost
diceRoll = Global.DiceRoll()
if diceRoll < chanceNew:
self.layer.CreateNode(self, self.memObject)
self.energy = self.energy - cost
effect = self.energy / Global.EPCreateEnergy
for node in nodesAround:
node.Train(self, effect)
self.intenseMemObjToNodes(effect)
self.energy = self.energy * Global.EPFadeCoef
if self.energy < Global.EPFadeLimit:
self.layer.DeleteEnergyPoint(self)
def simulationThread(self):
world = Global.World
self.lockBack = Lock()
self.lockBack.acquire()
while True:
world.Step()
self.RenderState(world)
self.mapRenderer.RenderToFile(world, "../../exs/PIL" + str(world.step).zfill(6) + ".png", ["agent", "ov", "eps", "info"])
# used only to get EPS of test rooms
#p=self.wxCanvas.postscript(width="1020",height="1020")
#f=open("image" + str(world.step) + ".eps", "wb")
#f.write(p)
#f.close()
if self.lock.acquire(False): break
self.playbackLock.acquire()
self.playbackLock.release()
self.lockBack.release()
Global.LogEnd()
return
def GetRandomHighLevelIntention(self):
return Global.Choice(self.highLevelIntentions)
def SaveScenario(self):
for i in self.intentions:
Global.LogData("scenario", i.name)
def SaveStatus(self):
status = str(Global.GetStep()) + ";" + str(
self.index) + ";%.4f;%.4f;%.4f;%.4f;%.4f;%.4f;%.4f" % (
self.x, self.y, self.level, self.range, self.AGamount,
self.totalAGamount, self.slowAGamount)
Global.LogData("place-status", status)
def Step(self):
action = self.intelligence.GetAction()
map = Global.Map
self.x = self.newX
self.y = self.newY
self.viewCones = self.viewConesNormal #fake else-than-Explore/LookForObject-action branch
self.viewConeMaxDist = self.viewConeNormalMaxDist
#execute action - world/agent-impacting part of atomic process
if action.process.name == "ExecuteReal":
action.sources = action.parent.parent.process.sources
Global.Log("AGENT is doing " + action.data['process'].name +
" for " + str(action.duration) + " seconds")
self.intelligence.UseObjects(action.parent.parent)
#map.UseObjects(self, action.parent) done in PF.UseObjects
elif action.process.name == "Execute":
pass #never happen - done as ExecuteReal or MoveTo(Partial)
elif action.process.name == "SearchRandom":
pass #never happens - done as MoveTo or Explore child process
elif action.process.name == "LookUpInMemory":
pass #never happens - done as Remember, MoveTo or LookForObject child process
elif action.process.name == "Remember":
action.duration = Global.Randint(1, 10)
action.data["phantom"] = self.intelligence.RememberObjectsFor(
action.data["affordance"])
if action.data["phantom"] != None:
Global.Log("AGENT is remembering for " +
action.data["affordance"].name +
"(there should be " +
action.data["phantom"].object.type.name + " at " +
str(action.data["phantom"].object.x) + "," +
str(action.data["phantom"].object.y) + ") for " +
str(action.duration) + " seconds")
else:
Global.Log("AGENT is remembering for " +
action.data["affordance"].name +
"(nothing in SM/MA) for " + str(action.duration) +
" seconds")
elif action.process.name == "LookForObject":
self.viewCones = self.viewConesForExplore
self.viewConeMaxDist = self.viewConeForExploreMaxDist
action.duration = Global.Randint(1, 5)
action.data["object"] = self.intelligence.LookForObject(
action.data["phantom"])
if action.data["object"] != None:
Global.Log("AGENT is looking for " +
action.data["phantom"].object.type.name +
"(Found) for " + str(action.duration) + " seconds")
else:
Global.Log("AGENT is looking for " +
action.data["phantom"].object.type.name +
"(NotFound) for " + str(action.duration) +
" seconds")
elif action.process.name == "MoveTo":
pass #never happens - done as MoveToPartial
elif action.process.name == "MoveToPartial":
dx = action.data['newx'] - self.newX
dy = action.data['newy'] - self.newY
angle = atan2(dx, dy)
self.dirAngle = angle
action.duration = map.MoveAgent(self, action.data['newx'],
action.data['newy'])
self.intelligence.UpdatePhantomsBecauseOfMove()
Global.Log("AGENT is moving to " + str(action.data['newx']) + "," +
str(action.data['newy']) + " for " +
str(action.duration) + " seconds")
elif action.process.name == "Explore":
self.viewCones = self.viewConesForExplore
self.viewConeMaxDist = self.viewConeForExploreMaxDist
action.duration = Global.Randint(5, 20)
action.sources = [action.data['affordance']]
Global.Log("AGENT is exploring for " +
action.data['affordance'].name + " for " +
str(action.duration) + " seconds")
else:
Global.Log("AGENT is a bit CONFUSED doing " + action.process.name)
#sees object around
visibleObjects = map.GetVisibleObjects(self)
self.intelligence.NoticeObjects(visibleObjects, action)
self.intelligence.perceptionField.Update(action)
self.intelligence.memoryArea.Update(action)
self.paText = self.intelligence.processArea.GetText()
Global.Time.AddSeconds(action.duration)
self.intelligence.ActionDone()
self.intelligence.spaceMap.StepUpdate(action)
