ES

// Time variables

  int rawTime;

  double timeInterval;

  static double displayTime;

​

// General variables

  double scaleFactor;

  int translateX, translateY, delta, b4x, b4y, deltaX, deltaY;

  public static int appWidth, appHeight, maintainNum, startNumCreatures, forcedSpawns, superMutations;

  public static boolean play, showMenu, maintainPop, drawGenePoolGraph, showCreatureInfo, spawnMode, spawnClicking, saveFPS;

  final int brainLength = 12;

  public int tileResL = MAP_DIMENSIONS;

  public int tileResW = MAP_DIMENSIONS;

  public Creature[] creatures = new Creature[9999999];

  public Tile[][] tiles = new Tile[tileResW][tileResL];

​

// Currently selected

  public static Tile selectedTile;

  public static Creature selectedCreature;

​

// Map variables

// Note: To add more maps, simply add the .jpg file to the "Maps" folder.

  public static boolean[][] waterTiles;

  //static File[] mapOptions;

  //static File selectedMap;

​

public void setup()

{

  size(displayWidth, displayHeight);

  appWidth = displayWidth - 2 * APP_WIDTH_SUBTRACTION_FACTOR;

  appHeight = displayHeight - 2 * APP_HEIGHT_SUBTRACTION_FACTOR;

  surface.setSize(appWidth, appHeight);

  frameRate(FRAMERATE);

  textSize(DEFAULT_TEXTSIZE);

  timeInterval = GAME_SPEED;

  maintainPop = MAINTAIN_DEFAULT;

  maintainNum = START_MAINTAIN_NUM;

  scaleFactor = DEFAULT_SCALE_FACTOR;

  startNumCreatures = START_NUM_CREATURES;

  loadMap();

  managerStart();

  menuStart();

  selectedTile = null;

  selectedCreature = null;

  spawnClicking = spawnMode = showMenu = showCreatureInfo = saveFPS = false;

  play = drawGenePoolGraph = true;

  forcedSpawns = superMutations = 0;

  translateX = translateY = 20;

  displayTime = b4x = b4y = deltaX = deltaY = 0;

}

​

public void draw()

{

  if(MenuPath.path != MenuPath.CREATURE) selectedCreature = null;

  if(saveFPS)

  {

    if(play)

    {  

      progress();      

    }

    drawMenu();

  }

  else

  {

    if(mousePressed)

    {

      b4x = mouseX;

      b4y = mouseY;

    }

    if(play)

    {  

      progress();      

    }

    pushMatrix();

    if(selectedCreature != null)

    {

      scaleFactor = 2.0f;

      translateX = (int) (-scaleFactor * selectedCreature.locationX + p2pw(850));

      translateY = (int) (-scaleFactor * selectedCreature.locationY + p2pw(850));

    }

    translate(translateX, translateY);

    scale((float) scaleFactor);

    colorMode(RGB);

    background(100);

    fill(60);

    rect(p2pl(8), 0, p2pl(6), p2pw(10));

    fill(255, 255, 255);

    textSize(p2pl(30));

    drawWorld();

    popMatrix();

    drawMenu();

  }

}

​

public void progress()

{

  rawTime++;

  displayTime += timeInterval;

  displayTime += timeInterval;

  iterate(timeInterval);

  if(rawTime % 60 == 0)

  {

    cutGraphs();

    updateHistoryArrays();

  }  

}

​

public void keyPressed()

{

  // reset zoom and camera location

  if(key == 'r')

  {

    translateX = translateY = 20;

    scaleFactor = DEFAULT_SCALE_FACTOR;

    return;

  }

  // pause and unpause

  else if(key == ' ')

  {

    play = !play;

  }

  // toggle creature spawning on click

  else if(key == 's')

  {

    spawnMode = !spawnMode;

  }

  // kill all creatures

  else if(key == 'k')

  {

    killAll();

  }

}

​

public void mouseDragged(MouseEvent e)

  {

      translateX += mouseX - pmouseX;

      translateY += mouseY - pmouseY;

  }

​

public void mouseClicked()

{

  int mX = mouseX;

  int mY = mouseY;

  // clicked on world, not a menu, test for creature, tile, etc click

  boolean checkWorldClick = false;

  if(showMenu)

  {

    if(mX <= p2pl(1600) && mY >= p2pw(131))

    {

      if(DEBUG_PRINTS) System.out.println("check menu");

      checkWorldClick = true;

      mX -= translateX;

      mY -= translateY;

      mX /= scaleFactor;

      mY /= scaleFactor;

    }

  }

  else

  {

    if(mX <= p2pl(1600))

    {

      if(DEBUG_PRINTS) System.out.println("check no menu");

      checkWorldClick = true;

      mX -= translateX;

      mY -= translateY;

      mX /= scaleFactor;

      mY /= scaleFactor;

    }

  }

  if(menuButton.clicked(mX, mY))

  {

    showMenu = !showMenu;

    return;

  }

  if(start.clicked(mX, mY)) // start button

  {

    play = !play;

    return;

  }

  if(selectedCreature != null && creatureInfo.clicked(mX, mY))

  {

    showCreatureInfo = !showCreatureInfo;

    return;

  }

  if(showMenu)

  {

    //test for button clicks

    if(killAll.clicked(mX, mY)) // kill all button

    {

      selectedCreature = null;

      MenuPath.path = MenuPath.GENERAL;

      killAll();

      return;

    }

    if(spawn.clicked(mX, mY)) // spawn button

    {

      spawnMode = !spawnMode;

      return;

    }

    if(spawn20.clicked(mX, mY)) // spawn 20 button

    {

      spawnNumCreatures(20);

    }

    if(maintainAt.clicked(mX, mY)) // maintain at button

    {

      maintainPop = !maintainPop;

      return;

    }

    if(maintainPopNum.clicked(mX, mY)) // maintain number button

    {

      if(maintainNum == 1) maintainNum += 4;

      else maintainNum += 5;

      if(maintainNum > 50) maintainNum = 1;

      return;

    }

    /*

    if(findCreatureByID.clicked(mX, mY)) // find ID button

    {

      thread("findCreatureID");

      return;

    }

    */

    if(saveFPSbutton.clicked(mX, mY)) // FPS saver button

    {

      saveFPS = !saveFPS;

      return;

    }

  }

  if(checkWorldClick)

  {

    if(DEBUG_PRINTS) System.out.println("checkWorldClick, spawnMode?");

    if(spawnMode)

    {

      if(spawn.clicked(mX, mY)) spawnMode = !spawnMode;

      if(checkWorldClick(mX, mY)) addCreature(mX, mY);

      return;

    }

    if(DEBUG_PRINTS) System.out.println("not spawnMode");

    // test for creature click

    Creature clickedCreature = checkCreatureClick(mX, mY);

    if(clickedCreature != null)

    {

      if(DEBUG_PRINTS) System.out.println("creature click");

      selectedCreature = clickedCreature;

      return;

    }

    // test for tile click

    Tile clickedTile = checkTileClick(mX, mY);

    if(clickedTile != null)

    {

      if(DEBUG_PRINTS) System.out.println("tile click");

      selectedTile = clickedTile;

      return;

    }

  }

  MenuPath.path = MenuPath.GENERAL;

}

​

public void mouseWheel(MouseEvent e)

  {

      float delta = (float) (-e.getCount() > 0 ? 1.05 : -e.getCount() < 0 ? 1.0 / 1.05 : 1.0);

      scaleFactor *= delta;

      if (!(scaleFactor > 3.0) && !(scaleFactor < .2))

      {

          translateX -= mouseX;

          translateY -= mouseY;

          translateX *= delta;

          translateY *= delta;

          translateX += mouseX;

          translateY += mouseY;

      }

      if (scaleFactor > 3.0) scaleFactor = 3.0f;

      if (scaleFactor < .2) scaleFactor = .2f;

  }

​

public void loadMap()

{

  waterTiles = new boolean[100][100];

  for(int i = 0; i < 100; i++)

  {

    for(int j = 0; j < 100; j++)

    {

      if(6 < i && i < 94 && 6 < j && j < 94) waterTiles[i][j] = false;

      else waterTiles[i][j] = true;

      if(30 < i && i < 70 && 42 < j && j < 56) waterTiles[i][j] = true;

      waterTiles[7][7] = true;

      waterTiles[93][7] = true;

      waterTiles[7][93] = true;

      waterTiles[93][93] = true;

      waterTiles[31][43] = false;

      waterTiles[31][55] = false;

      waterTiles[69][43] = false;

      waterTiles[69][55] = false;

    }

  }

}

​

public static double getDisplayTime()

{

  return displayTime;

}

​

// Run

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Manager

​

  public void managerStart()

  {

    startTiles();

    startCreatures();

  }

  public void drawWorld()

  {

    drawTiles();

    drawCreatures();

  }

  public void iterate(double timeInterval)

  {    

    iterateCreatures(timeInterval);

    iterateTiles();

    if(maintainPop) maintain();

  }

​

// Manager

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Prefs

​

  /** useful notes **/

    // asdf

   static class MenuPath

   {

     static int path = 0;

     static final int GENERAL = 0;

     static final int CREATURE = 1;

     static final int DATA = 2;

     static final int TILE = 3;

   }

  /** computer-based **/

    // pixel distance from left & right side of application to edge of monitor

    // DEFAULT = 68

    public final static int APP_WIDTH_SUBTRACTION_FACTOR = 68;

    // pixel distance from top & bottom side of application to edge of monitor

    // DEFAULT = 112

    public final static int APP_HEIGHT_SUBTRACTION_FACTOR = 112;

    // default text size for application

    // DEFAULT = 50

    public final static int DEFAULT_TEXTSIZE = 50;

    // starting application scale factor (visuals)

    // DEFAULT = 0.26

    public final static double DEFAULT_SCALE_FACTOR = 0.26;

  /** runtime preferences **/

    // enable or disable various console print statements

    // DEFAULT = false

    public final static boolean DEBUG_PRINTS = false;

    // default number to maintain the population

    // DEFAULT = 50

    public final static int START_MAINTAIN_NUM = 50;

    // automatically maintain population at the start?

    // DEFAULT = true

    public final static boolean MAINTAIN_DEFAULT = true;

    // base mutation chance

    // DEFAULT = 0.5

    public final static double MUTATE_CHANCE = 0.5;

    // chance of a large mutation in a creature's genes

    // DEFAULT = 0.05

    public final static double SUPER_MUTATE_CHANCE = 0.05;

    // number of default-generated creatures on application start

    // DEFAULT = 50

    public final static int START_NUM_CREATURES = 50;

    // amount of time that passes with each code iteration while ON

    // DEFAULT = 0.1

    public final static double GAME_SPEED = 0.1;

    // attempted FPS target

    // DEFAULT = 60

    public final static int FRAMERATE = 60;

    // should a creature die if they try to give birth without having enough mass?

    // using TRUE could significantly slow the rate of evolution (I think)

    // DEFAULT = false

    public final static boolean KILL_FOR_BIRTH_WITHOUT_MASS = false;

    // length & width of map, in tiles

    // don't change unless you adjust other code accordingly

    // DEFAULT = 100

    public final static int MAP_DIMENSIONS = 100;

    // how fast should tiles regenerate food?

    // DEFAULT = 0.025

    public final static double TILE_REGEN_RATE = 0.025;

    // how many code iterations until a dead tile can regen?

    // DEFAULT = 100

    public final static int TILE_COOLDOWN_THRESH = 100;

    // how big should the menu graphs get before throwing out older data?

    // DEFAULT = 150

    public final static int DISPLAY_GRAPH_SIZE = 150;

  /** functions, don't edit **/

    // general sigmoid function for neural network

    public static double sigmoid(double x)

    {

      return (2.0 / (1 + pow((float)Math.E, (float)-(x / 1.0)))) - 1.0;

    }

    // slightly modified sigmoid function for reproduction color transformation (Menu)

    public static double colorSigmoid(double x)

    {

      return (2.0 / (1 + pow((float)Math.E, (float)-(x / 1.5)))) - 1.0;

    }

    // distance formula

    public static double distBtCoords(double x1, double y1, double x2, double y2)

    {

      return sqrt((float)((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)));

    }

    // conversion from pixels to proportion of the sceren lengthwise

    public static int p2pl(double frac)

    {

      return (int) (frac / 2600.0 * 1920);

    }

    // conversion from pixels to proportion of the sceren widthwise (height)

    public static int p2pw(double frac)

    {

      return (int) (frac / 1600.0 * 1080);

    }

​

// Prefs

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Menu

​

  double[] populationHistory;

  //Integer[][] sortedGeneHistory;

  public Button menuButton, creatureInfo;

  public Button start, killAll, spawn, spawn20, kill, maintainAt, maintainPopNum, findCreatureByID, saveFPSbutton;

  int popHistoryLength = 1;

  public void menuStart()

  {

    MenuPath.path = MenuPath.GENERAL;

    populationHistory = new double[DISPLAY_GRAPH_SIZE];

    //sortedGeneHistory = new Integer[1000][1000];

    populationHistory[0] = (double) START_NUM_CREATURES;

    menuInit();

  }

  public void menuInit()

  {

    menuButton = new Button(p2pl(2400), 0, p2pl(185), p2pw(120));

    start = new Button(p2pl(2400), p2pw(120), p2pl(185), p2pw(120));

    killAll = new Button(p2pl(0), 0, p2pl(200), p2pw(120));

    spawn = new Button(p2pl(200), 0, p2pl(200), p2pw(120));

    spawn20 = new Button(p2pl(400), 0, p2pl(250), p2pw(120));

    findCreatureByID = new Button(p2pl(650), 0, p2pl(200), p2pw(120));

    maintainAt = new Button(p2pl(850), 0, p2pl(280), p2pw(120));

    maintainPopNum = new Button(p2pl(1100), 0, p2pl(140), p2pw(120));

    creatureInfo = new Button(p2pl(1650), p2pw(250), p2pl(280), p2pw(120));

    saveFPSbutton = new Button(p2pl(1240), 0, p2pl(240), p2pw(120));

  }

  public void drawMenu()

  {

    // side bar path split

    switch(MenuPath.path)

    {

      case MenuPath.GENERAL:

      {

        colorMode(PConstants.RGB);

        generalMenu(displayTime, forcedSpawns, superMutations);

        drawButtons(play, showMenu, spawnMode, maintainPop, saveFPS, showCreatureInfo, maintainNum);

        //drawGenePoolHistoryGraph(p);

        drawPopulationGraph(maintainPop, maintainNum);

        break;

      }

      case MenuPath.CREATURE:

      {

        colorMode(PConstants.RGB);

        fill(60, 120);

        rect(p2pl(1600), 0, p2pl(1200), p2pw(2000));

        drawButtons(play, showMenu, spawnMode, maintainPop, saveFPS, showCreatureInfo, maintainNum);

        fill(selectedCreature.colorR, selectedCreature.colorG, selectedCreature.colorB);

        drawSingleCreature(selectedCreature);

        fill(255);

        textSize(p2pl(65));

        text("Creature Data", p2pl(1800), p2pw(100));

        textSize(p2pl(30));

        int spacing = 45;

        int shift = 420;

        int shift2 = 340;

        text("ID: " + selectedCreature.ID, p2pl(1800), p2pw(160));

        text("Age: " + (int) Math.rint(selectedCreature.fitness), p2pl(1800), p2pw(210));

        text("Generation: " + selectedCreature.generation, p2pl(2100), p2pw(160));

        text("Parent: " + selectedCreature.parentID, p2pl(2100), p2pw(210));

        text("Total Eaten: " + (int) Math.rint(selectedCreature.totalEaten), p2pl(1620), p2pw(shift + 0 * spacing));

        text("Total Decayed: " + (int) Math.rint(selectedCreature.totalDecayed), p2pl(1620), p2pw(shift + 1 * spacing));

        text("Location: ( " + (int) Math.rint(selectedCreature.locationX) + ", " + (int) Math.rint(selectedCreature.locationY) + " )", p2pl(1620), p2pw(shift + 2 * spacing));

        text("Left XY: ( " + (int) Math.rint(selectedCreature.leftSensorX) + ", " + (int) Math.rint(selectedCreature.leftSensorY) + " )", p2pl(1620), p2pw(shift + 3 * spacing));

        text("Mid XP: ( " + (int) Math.rint(selectedCreature.midSensorX) + ", " + (int) Math.rint(selectedCreature.midSensorY) + " )", p2pl(1620), p2pw(shift + 4 * spacing));

        text("Right XY: ( " + (int) Math.rint(selectedCreature.rightSensorX) + ", " + (int) Math.rint(selectedCreature.rightSensorY) + " )", p2pl(1620), p2pw(shift + 5 * spacing));

        text("Mouth XY: ( " + (int) Math.rint(selectedCreature.mouthSensorX) + ", " + (int) Math.rint(selectedCreature.mouthSensorY) + " )", p2pl(1620), p2pw(shift + 6 * spacing));

        text("Heading: " + (int) Math.rint((selectedCreature.rotation * 180 / Math.PI)), p2pl(1620), p2pw(shift + 7 * spacing));

        text("Size Decay", p2pl(2200), p2pw(shift2 + 0 * spacing));

        text("Age Decay", p2pl(2200), p2pw(shift2 + 1 * spacing));

        text("Eat Decay", p2pl(2200), p2pw(shift2 + 2 * spacing));

        text("Turn Decay", p2pl(2200), p2pw(shift2 + 3 * spacing));

        text("Fwd Decay", p2pl(2200), p2pw(shift2 + 4 * spacing));

        text("Att Decay", p2pl(2200), p2pw(shift2 + 5 * spacing));

        text("Eat Rate", p2pl(2200), p2pw(shift2 + 6 * spacing));

        fill(95, 260, 220);

        text("Current Size: " + (int)selectedCreature.size, p2pl(2200), p2pw(shift2 + 10 * spacing));

        fill(0);

        fill(255, 0, 0);

        text(String.format("%.2f", selectedCreature.sizeDecay), p2pl(2400), p2pw(shift2 + 0 * spacing));

        text(String.format("%.2f", selectedCreature.fitnessDecay), p2pl(2400), p2pw(shift2 + 1 * spacing));

        text(String.format("%.2f", selectedCreature.eatRateDecay), p2pl(2400), p2pw(shift2 + 2 * spacing));

        text(String.format("%.2f", selectedCreature.rotationDecay), p2pl(2400), p2pw(shift2 + 3 * spacing));

        text(String.format("%.2f", selectedCreature.forwardDecay), p2pl(2400), p2pw(shift2 + 4 * spacing));

        text(String.format("%.2f", selectedCreature.attackDecay), p2pl(2400), p2pw(shift2 + 5 * spacing));

        fill(0, 255, 0);

        text(String.format("%.2f", selectedCreature.eatRate), p2pl(2400), p2pw(shift2 + 6 * spacing));

        if(selectedCreature.energyChange < 0) fill(255, 0, 0);

        else fill(0, 255, 0);

        text("Energy Change: " + String.format("%.2f", selectedCreature.energyChange), p2pl(2200), p2pw(shift2 + 8 * spacing));

        fill(255);

        if(showCreatureInfo)

        {

          if(selectedCreature.nearestCreature != null)

          {

            text("Nearest Creature ID: " + selectedCreature.nearestCreature.ID, p2pl(1620), p2pw(shift + 8 * spacing));

            text("Nearest ID Distance: " + String.format("%.2f", selectedCreature.distToNearest), p2pl(1620), p2pw(shift + 9 * spacing));

            text("Nearest ID Color Diff: " + selectedCreature.colorDifferenceToNearest, p2pl(1620), p2pw(shift + 10 * spacing));

            text("Angle change to nearest: " + String.format("%.2f", selectedCreature.angleToNearest), p2pl(1620), p2pw(shift + 11 * spacing));

            text("Creatures within 10 Tiles: " + selectedCreature.numCreaturesWithin10, p2pl(1620), p2pw(shift + 12 * spacing));

          }

          else

          {

            text("Nearest Creature ID: null", p2pl(1620), p2pw(shift + 8 * spacing));

            text("Nearest ID Distance: null", p2pl(1620), p2pw(shift + 9 * spacing));

            text("Nearest ID Color Diff: null", p2pl(1620), p2pw(shift + 10 * spacing));

            text("Angle change to nearest: null", p2pl(1620), p2pw(shift + 11 * spacing));

            text("Creatures within 10 Tiles: 0", p2pl(1620), p2pw(shift + 12 * spacing));

          }

        }

        else drawCreatureBrain(selectedCreature);

        break;

      }

      case MenuPath.DATA:

      {

        break;

      }

      case MenuPath.TILE:

      {

        colorMode(PConstants.RGB);

        fill(60, 120);

        rect(p2pl(1600), 0, p2pl(1200), p2pw(2000));

        colorMode(PConstants.HSB, 360, 100, 100);

        fill(selectedTile.colorH, selectedTile.colorS, selectedTile.colorV);

        rect(p2pl(1620), p2pw(140), p2pl(200), p2pl(200)); // draw the tile

        colorMode(PConstants.RGB, 255, 255, 255);

        drawButtons(play, showMenu, spawnMode, maintainPop, saveFPS, showCreatureInfo, maintainNum);

        fill(255, 255, 255);

        textSize(p2pl(70));

        text("Selected Tile Data", p2pl(1620), p2pw(110));

        textSize(p2pl(30));

        text("Tile #" + selectedTile.tileNumber, p2pl(1630), p2pw(200));

        text("Food: " + String.format("%.2f", selectedTile.food), p2pl(1630), p2pw(460));

        text("Row and Column: (" + (selectedTile.xIndex) + ", " + (selectedTile.yIndex) + ")", p2pl(1850), p2pw(200));

        text("Regeneration Value: " + Math.round( (selectedTile.regenValue * 1000) ) / 1000.0, p2pl(1850), p2pw(250));

        text("HSV: " + selectedTile.colorH + ", " + selectedTile.colorS + ", " + selectedTile.colorV, p2pl(1850), p2pw(300));

        text("x Range: " + selectedTile.x + " to " + (selectedTile.x + tileSize), p2pl(1850), p2pw(350));

        text("y Range: " + selectedTile.y + " to " + (selectedTile.y + tileSize), p2pl(1850), p2pw(400));

        textSize(p2pl(45));

        text("Tile Cooldown Status:  " + selectedTile.deadCooldown + " / " + TILE_COOLDOWN_THRESH, p2pl(1620), p2pw(600));

        break;

      }

    }

  }

  public void updateHistoryArrays()

  {

    populationHistory[popHistoryLength] = (double) (aliveCreatures);

    maxObservedCreatures = (int) Math.max(maxObservedCreatures, populationHistory[popHistoryLength]);

    popHistoryLength++;

    /*

    ArrayList<Integer> allColors = new ArrayList<Integer>();

    List<Integer> allColorsSorted = null;

    for(int i = 0; creatures[i] != null; i++)

    {

      allColors.add(creatures.get(i).color.hashCode());

    }

    allColorsSorted = allColors.subList(0, allColors.size());

    Collections.sort(allColorsSorted);

    sortedGeneHistory.add(allColorsSorted);

    */

  }

  public void generalMenu(double time, int forcedSpawns, int superMutations)

  {

    int startLabels = 120;

    int generalSpacing = 50;

    colorMode(PConstants.RGB);

    fill(60, 120);

    rect(p2pl(1600), 0, p2pl(1200), p2pw(2000));

    textSize(p2pl(50));

    fill(200);

    text("World Time: " + (int) Math.rint(time), p2pl(1620), p2pw(100));

    textSize(p2pl(30));

    fill(255);

    text("Starting Creature Count: " + startNumCreatures, p2pl(1620), p2pw(startLabels + 1 * generalSpacing));

    text("Current Creature Count: " + (aliveCreatures), p2pl(1620), p2pw(startLabels + 2 * generalSpacing));

    fill(0, 255, 0);

    text("Total Creature Births: " + creatureBirths, p2pl(1620), p2pw(startLabels + 5 * generalSpacing));

    fill(255, 0, 0);

    text("Total Creature Deaths: " + creatureDeaths, p2pl(1620), p2pw(startLabels + 6 * generalSpacing));

    fill(255);

    String sign;

    if(startNumCreatures > aliveCreatures) sign = "-";

    else if(startNumCreatures == aliveCreatures) sign = "";

    else sign = "+";

    if(sign.equals("+")) fill(0, 255, 0);

    else if(sign.equals("-")) fill(255, 0, 0);

    else fill(95, 260, 220);

    text("Total Change: " + sign + Math.abs(aliveCreatures - startNumCreatures), p2pl(1620), p2pw(startLabels + 3 * generalSpacing));

    fill(255);

    text("Total Existed: " + creatureCount, p2pl(1620), p2pw(startLabels + 8 * generalSpacing));

    text("Forced Spawns: " + forcedSpawns, p2pl(1620), p2pw(startLabels + 9 * generalSpacing));

    text("Super Mutations: " + superMutations, p2pl(1620), p2pw(startLabels + 10 * generalSpacing));

  }

  public void drawButtons(boolean play, boolean showMenu, boolean spawnMode, boolean maintainPop, boolean saveFPS, boolean showCreatureInfo, int maintainNum)

  {

    colorMode(PConstants.RGB);

    fill(170, 170, 170);

    textSize(p2pl(35));

    menuButton.drawButton();

    start.drawButton();

    fill(255, 255, 255);

    text("Menu", menuButton.getTextX(), menuButton.getTextY());

    if(play) fill(119, 255, 51);

    else fill(255, 51, 51);

    if(play) text("On", start.getTextX(), start.getTextY());

    else text("Off", start.getTextX(), start.getTextY());

    textSize(p2pl(30));

    colorMode(PConstants.HSB);

    fill((int)(frameRate / 30.0 * 100), 200, 200);

    text("FPS: " + (int) Math.rint(frameRate), start.getX(), start.getY() + 100);

    colorMode(PConstants.RGB);

    textSize(p2pl(35));

    if(showMenu)

    {

      fill(60, 120);

      rect(0, 0, p2pl(1600), p2pw(130));

      fill(170, 170, 170);

      killAll.drawButton();

      spawn.drawButton();

      spawn20.drawButton();

      maintainAt.drawButton();

      maintainPopNum.drawButton();

      findCreatureByID.drawButton();

      saveFPSbutton.drawButton();

      fill(255, 255, 255);

      text("Kill All", killAll.getTextX(), killAll.getTextY());

      if(spawnMode) fill(119, 255, 51);

      else fill(255, 51, 51);

      text("Spawn", spawn.getTextX(), spawn.getTextY());

      fill(255, 255, 255);

      text("Spawn 20", spawn20.getTextX(), spawn20.getTextY());

      if(maintainPop) fill(119, 255, 51);

      else fill(255, 51, 51);

      text("Maintain At", maintainAt.getTextX(), maintainAt.getTextY());

      fill(255, 255, 255);

      text(maintainNum, maintainPopNum.getTextX(), maintainPopNum.getTextY());

      text("Find ID", findCreatureByID.getTextX(), findCreatureByID.getTextY());

      if(saveFPS) fill(119, 255, 51);

      else fill(255, 51, 51);

      text("FPS Saver", saveFPSbutton.getTextX(), saveFPSbutton.getTextY());

      fill(255, 255, 255);

    }

    if(MenuPath.path == MenuPath.CREATURE)

    {

      creatureInfo.drawButton();

      fill(255);

      if(!showCreatureInfo)

      {

        text("Brain Info", creatureInfo.getTextX(), creatureInfo.getTextY());

      }

      else text("Debug Info", creatureInfo.getTextX(), creatureInfo.getTextY());

    }

  }

  public void drawPopulationGraph(boolean maintainPop, int maintainNum)

  {

    int horizontalPosition = 1650;

    int verticalPosition = 1350;

    int graphWidth = 900;

    int graphHeight = 200;

    colorMode(PConstants.RGB);

    fill(255);

    textSize(p2pl(30));

    text("Relative Population Over Time", p2pl(horizontalPosition), p2pw(verticalPosition - 20));

    rect(p2pl(horizontalPosition), p2pw(verticalPosition - 10), p2pl(graphWidth), p2pw(graphHeight + 20));

    fill(0, 0, 255);

    int width = graphWidth / popHistoryLength;

    if(maintainPop) stroke(0, 255, 0);

    else stroke(255, 0, 0);

    line(p2pl(horizontalPosition), p2pw(verticalPosition + (graphHeight - (int)(1.0 * maintainNum / maxObservedCreatures * graphHeight))), 

        p2pl(horizontalPosition + graphWidth), p2pw(verticalPosition + (graphHeight - (int)(1.0 * maintainNum / maxObservedCreatures * graphHeight))));

​

    stroke(100);

    for(int i = 0; i < popHistoryLength-1; i++)

    {

      double ratio = (populationHistory[i] / maxObservedCreatures * graphHeight);

      double toRatio = (populationHistory[i+1] / maxObservedCreatures * graphHeight);

      line(p2pl(horizontalPosition + (i)*width), p2pw(verticalPosition + (graphHeight - (int)ratio)), p2pl(horizontalPosition + (i+1)*width), p2pw(verticalPosition + (graphHeight - (int)toRatio)));

      ellipse(p2pl(horizontalPosition + (i+1)*width), p2pw(verticalPosition + (graphHeight - (int)toRatio)), p2pw(5), p2pw(5));

    }

  }

  /*

  public void drawGenePoolHistoryGraph(PApplet p)

  {

    if(!Run.drawGenePoolGraph) return;

    if(sortedGeneHistory.size() == 0) return;

    if(creatures.size() == 0) return;

    colorMode(PConstants.RGB);

    fill(255);

    textSize(p2pl(30));

    double horizontalPosition = 1650.0;

    fill(255);

    // vertical positioning of the graph

    double verticalPosition = 1080.0;

    double graphHeight = 200.0;

    double graphWidth = 900.0;

    // pixel length of each entry of the history

    double unitWidth = graphWidth / sortedGeneHistory.size();

    text("Gene Pool History", p2pl(horizontalPosition), p2pw(verticalPosition - 15));

    for(int record = 0; record < sortedGeneHistory.size(); record++)

    {

      double entryHeight = graphHeight / sortedGeneHistory.get(record).size();

      for(int entry = 0; entry < sortedGeneHistory.get(record).size(); entry++)

      {

        fill(sortedGeneHistory.get(record).get(entry));

        stroke(sortedGeneHistory.get(record).get(entry));

        rect(p2pl(horizontalPosition) + p2pl(record * unitWidth), p2pw((int)verticalPosition) + p2pw(entry * entryHeight), 

            p2pl(unitWidth), p2pw(entryHeight));

      }

    }

    stroke(0);

  }

  */

  public void cutGraphs()

  {

    int cutSize = DISPLAY_GRAPH_SIZE;

    boolean cutPopulationHistory = false;

    //boolean cutGeneHistory = false;

    if(popHistoryLength >= cutSize) cutPopulationHistory = true;

    //if(sortedGeneHistory.size() > cutSize) cutGeneHistory = true;

    if(cutPopulationHistory)

    {

      for(int i = 0; i < popHistoryLength - 1; i++)

      {

        populationHistory[i] = populationHistory[i + 1];

      }

      popHistoryLength--;

    }

    //if(cutGeneHistory) sortedGeneHistory = sortedGeneHistory.subList(sortedGeneHistory.size() - cutSize, sortedGeneHistory.size() - 1);

  }

  public void drawSingleCreature(Creature c) // done, not sure how it works, so don't touch!!!!!

  {

    colorMode(PConstants.RGB);

    fill(c.colorR, c.colorG, c.colorB); // 1700, 320

    int leftSensorXChange = (int) (c.leftSensorX - c.locationX);

    int leftSensorYChange = (int) (c.leftSensorY - c.locationY);

    int rightSensorXChange = (int) (c.rightSensorX - c.locationX);

    int rightSensorYChange = (int) (c.rightSensorY - c.locationY);

    int killerXChange = (int) (c.midSensorX - c.locationX);

    int killerYChange = (int) (c.midSensorY - c.locationY);

    stroke(50);

    line(p2pl(1700), p2pw(150), p2pl(1700) + leftSensorXChange, p2pw(150) + leftSensorYChange);

    line(p2pl(1700), p2pw(150), p2pl(1700) + rightSensorXChange, p2pw(150) + rightSensorYChange);

    line(p2pl(1700), p2pw(150), p2pl(1700) + killerXChange, p2pw(150) + killerYChange);

    stroke(0);

    colorMode(PConstants.HSB);

    fill(c.leftSensorColor, 120, 120);

    ellipse(p2pl(1700) + leftSensorXChange, p2pw(150) + leftSensorYChange, p2pw(15) * 1, p2pw(15) * 1);

    fill(c.rightSensorColor, 120, 120);

    ellipse(p2pl(1700) + rightSensorXChange, p2pw(150) + rightSensorYChange, p2pw(15) * 1, p2pw(15) * 1);

    colorMode(PConstants.RGB);

    fill(c.colorR, c.colorG, c.colorB);

    ellipse(p2pl(1700), p2pw(150), (int)c.diameter * 1, (int)c.diameter * 1);

    fill(255);

  }

  public void drawCreatureBrain(Creature c) // top left = 1620, 800

  {

    int verticalSpacing = p2pw(640 / brainLength);

    textSize(p2pw(50));

    text("Inputs", p2pl(1620), p2pw(900));

    text("Hidden Layers", p2pl(1940), p2pw(900));

    text("Outputs", p2pl(2400), p2pw(900));

    colorMode(PConstants.RGB);

    // Left food, center food, mouth food, right food, size, ......

    textSize(p2pw(30));

    text("L Food", p2pl(1610), p2pw(950) + verticalSpacing * 0);

    text("C Food", p2pl(1610), p2pw(950) + verticalSpacing * 1);

    text("M Food", p2pl(1610), p2pw(950) + verticalSpacing * 2);

    text("R Food", p2pl(1610), p2pw(950) + verticalSpacing * 3);