bhickey / skynet Goto Github PK

see title

Sometimes we can't see everything. We should maintain a probabilistic model of the unseen universe.
Enemy ants that have fallen out of our field of vision should diffuse (random walk model?)
If we saw some food, then walked away (why would we do that?!) and walked back and it's gone we should assume an enemy ant knicked it.
Hills -- if we know where hills aren't, we can guess at where they are.

Can we put this information into use in our decision making?

(Assigned to you Daniel for the sake of conversation)

World is not a self-contained torus. It's an array. This bites.

We need an automated test for this test.sh builds our bot and the attempt to invoke the competition tool to run it. Something is going wrong with the current directory and the universe breaks.

The Haskell starter stuffs objects (food, ants, hills) into the same grid as land and water. I believe that this is a mistake. We should separate out our representation so that we don't conflate these ideas.

At our last meeting Eric pointed out that the function 'passable' will return a bad result. I've observed a consequence of this by watching some games -- ants will advance in alternating ranks slowing down the entire formation.

Maps are designed to be fair. This obliges them to have some symmetry, be it rotational, translational, mirror, whatever.

Rather than blindly exploring the map, let's exploit symmetry to predict the structure of the map and fill in the blanks where we can.

See title.

Just kidding.

Learn Haskell. Or else.

We should probably use hierarchical A* for this.

1. Decompose your grid into blocks, organize the blocks into blocks, it's block all the way down.
2. Compute the cost of traversing the edges between the blocks.
3. Find a path from where you are to the edge of a block.
4. Traverse your blocky structure until you reach a block containing your destination.
5. Pop your way out to the destination.

I'll just start with a Dijkstra pathfinder. If that sucks we'll implement the above.

Our greedy bot only sporadically moves. Figure out why, please.
(I'd appreciate a second set of eyes on my pathfinding code)

Watching games I've noticed ants getting jammed up in bottlenecks. To avoid this, we should compute the capacity of paths connecting different parts of the map. This requires that we segment the map and build an abstract graph on top of the grid.

Want to talk about this one on the phone?

pyc files are generated and do not belong in source control.