features.txt

Features to add/consider for the agent simulation
-------------------------------------------------

Code cleanup? for-else or while-else loops to clean up logic?

Expand vision to allow for up to 4-6 cells of view
Update chosen direction to be weighted based on vision (possibly use Gallant's circle code to make a direction based on weighted view 'wedge' - possibly too complicated)
Add water to the environment (eg. small streams=1, river join cell=sum of previous)
Add topo to the environment
Add memory: recall up to X coords (in LRU cache) of high value cells (food, water) OR give each agent a networkx/tree structure to remember good cells/routes taken. Use that to optimise for taking a shorter path between places of interest (will be of more use when agents require different types of resources)

Add in travel difficulty to cells: steeper/vegetated cells require more energy to move across
Pollution and semi permanent depletion of cells?
Trade food & water?
Measure which cells see the most traffic/become paths
Measure length of life [young|    adult      | elderly]
Add clans / family: young agents tail parents until a specific age


Search mechanisms:
* Add 'intelligent' search: find water by going downwards to find streams
* Upwards to climb peaks and get a better view of surrounding area (eg. double or triple the vision when on a peak cell to locate food)


Other simulations:
* More detailed simulation of daily activities (leave shelter, get water, find food, care for & feed child agents, return to shelter)
* Add terrain traversal algorithms for travelling from shelter out to food/water gathering areas. Use to investigate patterns other than constant circular harvesting/stasis in early variants of the simulation.
* Simplify turns, agents have 1 action per turn? (move, harvest, trade etc)
  - Agents will need to focus on individual objectives, rather than constant task swapping
  - Program in Maslow's Hierarchy of needs?
  - Try algorithm to remain closer to home base instead of a large circular search pattern. Initial version: "remember" the cell closest overall to home cell with most energy value. Examine how this affects earlier behaviour with vast swathes of harvesting.
* Try environment layout with lots of smaller/easily depleted harvest spaces (force agents to move often)
* Simulate Aboriginal hunter gatherers? Don't stockpile resources, leave resources behind, try to focus on longevity of the environment/recovery. Add in greedy agents, examine effects on simulation population as a whole.
* Seasonal changes and weather? Less growth over winter, see how that affects population. Drought: make rivers grow/shrink depending on time


Urban Microsimulation
---------------------

Possible things to track:
* Waste (household -> recycling and to landfill. Sewerage, rainwater? How does it affect pollution elsewhere?)
* Transport (choice options: walk, ride, drive, bus)  Relation to hills, distance, fitness
  Use networkx as part of transport systems/roads to measure/simulate congestion etc?
* Water consumption
* Energy use (Transport, in the home, in offices)
* Map to obesity, alienation from areas, lack of transport options

For the purposes of what? Measure overall effects of housing design, larger impacts from cities/dev, city design effects, energy flows, effects on people, effects on the environment → maybe try and get some kind of holistic sustainability model incorporating several different factors. Give overall rating of impacts. Problems: complex and could involve a lot of factors. Would have to combine simpler smaller models.




Other Thoughts
--------------

Coordinate class for cleaner code. Could add adjacent cells as a method?

class Coordinate2D(object):
    def __init__(self, y, x):
        # TODO: slots
        self.y = y
        self.x = x

    def offset(self, yoff, xoff):
        """Return (y,x) tuple coordinate of that offset"""
        return (self.y + yoff, self.x + xoff)

    def update(self, yoff, xoff):
        """Update coordinate with an offset"""
        self.y += yoff
        self.x += xoff

    # TODO: possible idea, call obj to return coords
    def __call__(self):
        return (self.y, self.x)