ALife.Creatur.Universe

Provides a habitat for artificial life.

Constructors

class (Clock (Clock u), Logger (Logger u), Database (AgentDB u), Namer (Namer u), Checklist (Checklist u), Agent (Agent u), Record (Agent u), Agent u ~ DBRecord (AgentDB u)) => Universe u where

A habitat containing artificial life.

Associated Types

type Agent u

type Clock u

type Logger u

type AgentDB u

type Namer u

type Checklist u

Methods

clock :: u -> Clock u

setClock :: u -> Clock u -> u

logger :: u -> Logger u

setLogger :: u -> Logger u -> u

agentDB :: u -> AgentDB u

setAgentDB :: u -> AgentDB u -> u

agentNamer :: u -> Namer u

setNamer :: u -> Namer u -> u

checklist :: u -> Checklist u

setChecklist :: u -> Checklist u -> u

Instances

(Agent a, SizedRecord a) => Universe (CachedUniverse a)

(Agent a, Record a) => Universe (SimpleUniverse a)

data SimpleUniverse a

Instances

Eq (SimpleUniverse a)

Show (SimpleUniverse a)

(Agent a, Record a) => Universe (SimpleUniverse a)

type Agent (SimpleUniverse a) = a

type Clock (SimpleUniverse a) = PersistentCounter

type Logger (SimpleUniverse a) = SimpleLogger

type AgentDB (SimpleUniverse a) = FSDatabase a

type Namer (SimpleUniverse a) = SimpleNamer

type Checklist (SimpleUniverse a) = PersistentChecklist

data CachedUniverse a

Instances

Eq a => Eq (CachedUniverse a)

Show a => Show (CachedUniverse a)

(Agent a, SizedRecord a) => Universe (CachedUniverse a)

type Agent (CachedUniverse a) = a

type Clock (CachedUniverse a) = PersistentCounter

type Logger (CachedUniverse a) = SimpleLogger

type AgentDB (CachedUniverse a) = CachedFSDatabase a

type Namer (CachedUniverse a) = SimpleNamer

type Checklist (CachedUniverse a) = PersistentChecklist

mkSimpleUniverse :: String -> FilePath -> SimpleUniverse a

mkCachedUniverse :: String -> FilePath -> Int -> CachedUniverse a

Clock

currentTime :: Universe u => StateT u IO Time

The current "time" (counter) in this universe

incTime :: Universe u => StateT u IO ()

Increment the current "time" (counter) in this universe.

Logging

writeToLog :: Universe u => String -> StateT u IO ()

Write a message to the log file for this universe.

Database

agentIds :: Universe u => StateT u IO [AgentId]

Returns the list of agents in the population.

archivedAgentIds :: Universe u => StateT u IO [AgentId]

Returns the list of (dead) agents in the archive.

popSize :: Universe u => StateT u IO Int

Returns the current size of the population.

getAgent :: (Universe u, Serialize (Agent u)) => AgentId -> StateT u IO (Either String (Agent u))

Fetches the agent with the specified ID from the population. Note: Changes made to this agent will not "take" until store is called.

getAgentFromArchive :: (Universe u, Serialize (Agent u)) => AgentId -> StateT u IO (Either String (Agent u))

Fetches the agent with the specified ID from the archive.

getAgents :: (Universe u, Serialize (Agent u)) => [AgentId] -> StateT u IO (Either String [Agent u])

Fetches the agents with the specified IDs from the population.

store :: (Universe u, Serialize (Agent u)) => Agent u -> StateT u IO ()

If the agent is alive, adds it to the population (replacing the the previous copy of that agent, if any). If the agent is dead, places it in the archive.

Names

genName :: Universe u => StateT u IO AgentId

Generate a unique name for a new agent.

Agent programs

type AgentProgram u = Agent u -> StateT u IO (Agent u)

A program involving one agent. The input parameter is the agent. The program must return the agent (which may have been modified).

withAgent :: (Universe u, Serialize (Agent u)) => AgentProgram u -> AgentId -> StateT u IO ()

Run a program involving one agent

type AgentsProgram u = [Agent u] -> StateT u IO [Agent u]

A program involving multiple agents. The input parameter is a list of agents. The program must return a list of agents that have been *modified*. The order of the output list is not important.

withAgents :: (Universe u, Serialize (Agent u)) => AgentsProgram u -> [AgentId] -> StateT u IO ()

isNew :: Universe u => AgentId -> StateT u IO Bool

Agent rotation

lineup :: Universe u => StateT u IO [AgentId]

Returns the current lineup of (living) agents in the universe. Note: Check for endOfRound and call refreshLineup if needed before invoking this function.

startOfRound :: Universe u => StateT u IO Bool

Returns true if no agents have yet their turn at the CPU for this round.

endOfRound :: Universe u => StateT u IO Bool

Returns true if the lineup is empty or if all of the agents in the lineup have had their turn at the CPU for this round.

refreshLineup :: Universe u => StateT u IO ()

Creates a fresh lineup containing all of the agents in the population, in random order.

markDone :: Universe u => AgentId -> StateT u IO ()

Mark the current agent done. If it is still alive, it will move to the end of the lineup.