Release version: 0.1 Authors: Chris Browne [email protected] James Ward <>

Current Status: Working on a connect four AI now, robot stuff can wait. Connect four uncompilable, but we're close.

The below Psuedocode is now completely at odds with the current implementation. Despite its embarrassingly naive approach, I've decided to leave it in as a historical reminder of how far we've come.

--- PSUEDOCODE ---

We originally worked from this Psuedocode:

Summary of changes: v0.4 -> v0.5 (Chris changed:) added strobeSensor and wallSensor to Robot

v0.3 -> v0.4 (Spoon changed:)
Removed Robot.heading
Removed RobotScores and replaced with Population
Moved robot creation and reproduction into Population (this makes main much shorter!)
Made Robot an implementation of Individual
Made RobotGenome an implementation of Genome
Individuals are now created by Genome.getIndividual()
Rearranged the order of class definitions

v0.2 -> v0.3 (Chris changed:)
return value of "tick()" to allow us to convert the step function into a sigmoidal one for smoother control
added genetic recombination stuff to allow for faster, more efficient mutation (see comment above main())
NB: we only technically need >3 robots in our gene pool, but the bigger the gene pool the faster it works
Also neatened up ChangeLog portion and moved it to the top of the file (where I believe it should belong)

v0.1 -> v0.2 (Spoon changed:)
MapSimulation now doesn't know about robots, just Items (Robot is an Item).
Changed the names of Cell, Contains to MapItem, Item. Cells is a property of MapSimulation.
Tried to make it clearer how the neural network could be put together.
Created a Genome class, which defines the shape of the network and the weights for a particular individual.
    Wasn't sure about NEURONS_PER_LAYER. Are there the same number of neurons in each layer?
    Genome has numberOfNeuronsInLayers, e.g. [5, 5, 3] is a 3-layer net with 5 neurons in first and second layers and 3 in last.
    I could have extended Genome with RobotGenome which has a definite shape (maybe that would be better).
I changed main a bit too; i think it's a bit clearer.

--END CHANGELOG--

MapSimulation(int width, int height):
    MapItem[] items,
    Item getItemAt(x, y)
    void setItemAt(x,y,item);

MapItem(int xpos, int ypos, Item item):
    int xpos, 
    int ypos,
    Item item

Enum Item:
    WALL, MINE, ROBOT, ...

Population(Genome g, int size):
    Individual[] indivuduals,
    void simulate(int numberOfTicks),
    void nextGeneration(), //perform reproduction and mutation to get a new array of individuals
    Genome currentGenome()

Interface Individual:
    MapSimulation map,
    NeuralNet neuralNet,
    int score, //updated after every tick with -n for crashes and +m for sought objects
    void tick() //call neuralNet.tick() and update world, xpos, ypos, score

Robot implements Individual(MapSimulation map, NeuralNetwork net):
    MapSimulation map,
    Item[] seeking,
    Item[] avoiding,
    int xpos,
    int ypos,
    int strobeSensor, // radar/sonar sensor that can tell us how close we are to a seekable
    int wallSensor, // lidar sensor that can tell us what is directly in front of the robot (and how far away it is)
    NeuralNet neuralNet,
    int score, //updated after every tick with -n for crashes and +m for sought objects
    void tick() //call neuralNet.tick() and update world, xpos, ypos, score
    Genome mate(Robot partner); // allowing genetic recombination (faster, more efficient evolution)

Interface Genome():
    int[] numberOfNeuronsInLayers,
    int[] weights //length is the sum of the number of links between layers
            // number of links = neurons in first layer * neurons in second layer
    Individual getIndividual()

RobotGenome implements Genome():
    int[] numberOfNeuronsInLayers,
    int[] weights //length is the sum of the number of links between layers
            // number of links = neurons in first layer * neurons in second layer
    Robot getIndividual()

NeuralNet(Genome g):
    NeuronLayer[] layers,
    int[] tick(int[] input) //call tick for each layer in turn passing result layer to layer

NeuronLayer(int numerOfNeurons, int[] weights):
    Neuron[] neurons,
    int[] tick(int[] input) //call tick for each neuron in layer

Neuron(int[] weights):
    int[] weights,
    int tick(int[] input)  //apply weights to each input.  Returns how much power to drive the track with

main(): Population pop = new Population(new RobotGenome(randomized_int_array), SIZE_OF_POPULATION) for(NUMBER_OF_GENERATIONS): pop.simulate(NUMBER_OF_TICKS) pop.nextGeneration()

RobotGenome g = pop.currentGenome()