citizen/CitizenClass.pde

import java.lang.Double;

class Citizen {
  int i_xSpawn, i_ySpawn, i_diameter;
  boolean b_linked;
  boolean b_moving;
  int i_home;
  String S_name;
  float f_xPos, f_yPos;
  float f_movementSpeed = 0.1;
  //0-100:
  //motivation (bei arbeiter montag ~40, freitag ~80 - 100)
  //7 emotionen?

  // berufsfeld: webdesigner, pädagoge, schmuckdesigner, schmied
  // berufsstatus: beamter, selbstständiger, unternehmer, angestellter, grundschüler, gymnasiast, hauptschüler, realschüler, azubi, student, rentner

  // identität: gelbhemd, lokal, regional, national, international, fremd, 






  Citizen(int home, String name) {
    i_home = home;
    S_name = name;
    i_diameter = 15;

    pathFinder = makePathFinder(gs, pathAlgorithm);
  }

  void spawn(int house) {
    PVector v2_spawnPoint = houses.get(house).v2_randomSpawnPoint();
    i_xSpawn = int(v2_spawnPoint.x);
    i_ySpawn = int(v2_spawnPoint.y);
    f_xPos = i_xSpawn;
    f_yPos = i_ySpawn;
    rNodes = pathFinder.getRoute(); 

    if (b_randomRun) goTo(int(random(0, width)), int(random(0, height)));
    b_linked = true;
  }

  void despawn() {
    b_linked = false;
  }


  boolean b_moveDiagonally() {
    if (int(rNodes[nextNode].xf()) != int(f_xPos) && int(rNodes[nextNode].yf()) != int(f_yPos)) {
      return true;
    } else {
      return false;
    }
  }
  int i_direction(float f, float v) {
    if (f <= 0-v) return -1;
    else if (f >= 0+v) return 1;
    else return 0;
  }

  void update() {
    if (b_moving) { //if rNodes.length > 0 
      if (rNodes.length > nextNode) {

        float f_xPosNext = rNodes[nextNode].xf();
        float f_yPosNext = rNodes[nextNode].yf();

        float f_movementVelo = f_movementSpeed;

        if (b_moveDiagonally()) f_movementVelo = f_movementVelo / 1.41;
        f_xPos += i_direction(f_xPosNext-f_xPos, f_movementVelo) * f_movementVelo;
        f_yPos += i_direction(f_yPosNext-f_yPos, f_movementVelo) * f_movementVelo;


        if (abs(f_yPos - f_yPosNext) < f_movementVelo && abs(f_xPos - f_xPosNext) < f_movementVelo) {
          f_yPos = f_yPosNext;
          f_xPos = f_xPosNext;
          nextNode++;
        }
      } else {
        b_moving = false;
        nextNode = 0;
        if (b_randomRun)goTo(int(random(0, width)), int(random(0, height)));
      }
    }
  }

  void display() {
    ellipse(f_xPos, f_yPos, i_diameter, i_diameter);
    textSize(10);
    text(S_name, f_xPos, f_yPos-10);

    //draw Route
    if (rNodes.length >= 2 && (b_drawPathLine || b_drawPathDestination)) {
      pushStyle();
      if (b_drawPathLine) {
        stroke(color(100, 100, 100));
        strokeWeight(1);
        noFill();
        for (int i = 1; i < rNodes.length; i++)
          line(rNodes[i-1].xf(), rNodes[i-1].yf(), rNodes[i].xf(), rNodes[i].yf());
      }
      if (b_drawPathDestination) {
        stroke(160, 0, 0);
        fill(255, 0, 0);
        ellipse(rNodes[rNodes.length-1].xf(), rNodes[rNodes.length-1].yf(), nodeSize, nodeSize);
      }
      popStyle();
    }
  }

  GraphNode startNode, endNode;
  int startNodeID, endNodeID;
  GraphNode[] rNodes;
  ArrayList<GraphNode> rNodesList = new ArrayList<GraphNode>();
  int nextNode;

  IGraphSearch pathFinder;
  int pathAlgorithm = i_pathAlgorithm;

  void goTo(int x, int y) {
    //add: go to node? go to house?
    float nodeDistance = 1.0f;
    while (gs.getNodeAt(f_xPos, f_yPos, 0, nodeDistance) == null) {
      nodeDistance++;
    }
    startNodeID = gs.getNodeAt(f_xPos, f_yPos, 0, nodeDistance).id();
    nodeDistance = 1.0f;
    while (gs.getNodeAt(x, y, 0, nodeDistance) == null) {
      nodeDistance++;
    }
    endNodeID = gs.getNodeAt(x, y, 0, nodeDistance).id();

    pathFinder.search(startNodeID, endNodeID, true); //returns null if no route is found

    rNodes = pathFinder.getRoute();

    if (rNodes.length > 0) {
      nextNode = 0;
      b_moving = true;

      for (int i = 0; i < rNodes.length; i++) {
        rNodesList.add(rNodes[i]);
      }
    } else {
      if (b_randomRun) goTo(int(random(0, width)), int(random(0, height)));
    }
    //else {
    //println("bloop");
    //    goTo(int(random(0,width)),int(random(0,height)));
    //b_moving = false; //this might be problematic if i want movement controlled by different things than goto / nodes
    //}
    //exploredEdges = pathFinder.getExaminedEdges();
  }
}