danielperezjensen / mapc-uva Goto Github PK
View Code? Open in Web Editor NEWThe UVA's entry into the Multi Agent Programming Contest
Home Page: https://multiagentcontest.org/
The UVA's entry into the Multi Agent Programming Contest
Home Page: https://multiagentcontest.org/
Run function should contain temporary role switching.
Run function should makes use of BDI functionality to handle actions.
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.
For learning purposes we require a way to generate paths that we can use as training data.
Tagging agents, allies and enemies, with an ID will improve tracking their movement.
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?
Could this function be moved from builder.py to agent.py? I think it is a basic function every role could use.
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?
Instead the new observations can be saved in the graph.
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.
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.
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.
Add functionality to BDI agent to unpack higher level functions and send primitive functions to the server
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?
With the ability to add functions as arguments, values that should be computed right before execution can be added.
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.
To print a message formatted with the coloured agent name in front and optionally with step information after.
This makes it easy to refer to in our thesises
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.
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.
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).
A declarative, efficient, and flexible JavaScript library for building user interfaces.
๐ Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. ๐๐๐
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google โค๏ธ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.