danielperezjensen / mapc-uva Goto Github PK

To print a message formatted with the coloured agent name in front and optionally with step information after.

For learning purposes we require a way to generate paths that we can use as training data.

With the ability to add functions as arguments, values that should be computed right before execution can be added.

MAPC added a new STATUS-REQUEST message you can access which sends valuable data back about the server config, which we can use to determine for example the amount of agents which we must create.

Run function should contain temporary role switching.
Run function should makes use of BDI functionality to handle actions.

Currently when we retrieve a node from the beliefs (graph) that doesn't yet exist we either get None or a node (from self.beliefs.get_node(coords)). But wouldn't it make more sense to simply treat the dictionary of nodes as a default dictionary, with a default value of an empty Node object? Like so:

from collections import defaultdict

self.nodes = defaultdict(Node)

Then now if we access the self.nodes dictionary for a key that does not yet exist it generates an empty node object and returns that instead of None or yielding an error.

Add functionality to BDI agent to unpack higher level functions and send primitive functions to the server

Instead the new observations can be saved in the graph.

Currently if we want to retrieve a node that may or may not exist yet in the graph we have to do this:

try:
    node = self.graph.nodes[(x, y)]
    # do whatever with node

Wouldn't it be better to have a function that simply either returns the node or None depending on if the node is already in the graph?

I think I would always create enough agents (and connect as many entities) for the biggest simulation (50) and see that they do not go crazy if they don't get percepts for some time :)

This was brought up in the google forum, maybe a better idea than what we are doing now?

link

This makes it easy to refer to in our thesises

Could this function be moved from builder.py to agent.py? I think it is a basic function every role could use.

In graph.py, we use the word nodes in function names such as:

def get_local_nodes() def get_new_nodes()

Even though the function returns node coordinates, and not the actual node objects. The name is not congruent with the docstring.

Maybe change the name, or make it return Nodes (I prefer the second option).

When a goal state consists of more than one block (see picture) the graph sees this as multiple goal states. There needs to be a function to find the center of this block of goal states.

I do actually need to use drop_intention when using the clear_fully() intention. As because if the target moves, I want to drop the intention (for now). I'll add that if the context is empty the intention tuple will not be dropped, but if there is a context then the graph must abide by that context. I think I'll use a list of tuple for this, with each tuple representing a coordinate and what thing must be on that coordinate.

In graph.py we are storing self.current like this:

self.current = {agent_id: self.nodes[(0, 0)]}

Why are we storing our current node like this instead of as a coordinate? Even though in the rest of the functions we always use the location of nodes instead of the specific instance of a node? Can we atleast add a variable that tracks the current location as a pair of coordinates?

There is still a confusing usage of the word node (and other things) in function names in graph.py. Such as:

def get_local_nodes(self, agent_id, offset=None):
    pass
def get_local_agents(self, agent_id, team='A'):
    pass

These two functions for example don't actualy return a Node or Agent object but they return coordinates.

As of now, agents do not know how to path-find with blocks attached. It would be great if there is a general solution to this problem.

The PEP-8 style guide does not allow for bare excepts, we do have bare excepts. We should replace them with the error we wish to catch.

Tagging agents, allies and enemies, with an ID will improve tracking their movement.

For comparing multi-agent building, single agents need to be able to create constructions on their own. Building this could form a basis for multi-agent construction.

When a new taskboard is seen by an agent, it is not correctly added to beliefs.things.