Satisfactory Graph Theory Proof-Of-Concept

NHandler nodeHandler;

Node test;

void setup() {
  size(1920, 1080);
  nodeHandler = new NHandler();
}

void draw() {
  background(51);

  if(frameCount % 30 == 0) nodeHandler.pulseQTYs();

  nodeHandler.render();

}




class Node {
  PVector pos;
  color col;

  color ringCol;
  float ringSize;

  int nodeID;

  NHandler handler;

  ArrayList<Integer> parents;
  ArrayList<Integer> children;

  boolean valid;

  int trueQTY;
  int infiniteRate;
  int reserveQTY1;
  int reserveQTY2;

  int pulseCount;

  Node(NHandler nh, int posx, int posy) {
    handler = nh;
    nodeID = handler.NodeIDsCreated;
    valid = true;
    parents = new ArrayList<Integer>();
    children = new ArrayList<Integer>();
    pos = new PVector(posx, posy);
    trueQTY = 0;
    reserveQTY1 = 0;
    reserveQTY2 = 0;
    infiniteRate = 15;
  }

  void setValid(boolean b) {
    valid = b;
  }

  void addParent(int parentID) {
    parents.add(parentID);
  }

  void addChild(int childID) {
    children.add(childID);
  }

  void tryRemoveParent(int parentID) {
    for (int i = parents.size()-1; i >= 0; i--) {
      if (parents.get(i) == parentID) {
        parents.remove(i);
      }
    }
  }

  void tryRemoveChild(int childID) {
    for (int i = children.size()-1; i >= 0; i--) {
      if (children.get(i) == childID) {
        children.remove(i);
      }
    }
  }

  void show(color f) {
    stroke(0);
    fill(f);
    circle(pos.x, pos.y, handler.nodeSize);
    fill(0);
    stroke(0);
    textSize(handler.textSize);
    if (parents.size()==0) {
      text(infiniteRate, pos.x, pos.y);
    } else {
      text(trueQTY, pos.x, pos.y);
    }
  }

  void pulseToChildren() {
    if (parents.size() == 0) {
      trueQTY = infiniteRate;
    }
    if (children.size()>0) {
      for (int i = trueQTY; i > 0; i--) {
        pulseCount++;
        handler.getNodeByID(children.get(pulseCount % (children.size()))).reserveQTY1++;
        trueQTY--;
      }
    } else {
      trueQTY = 0;
      reserveQTY2 = 0;
    }
  }
}






class NHandler {
  int NodeIDsCreated;
  ArrayList<Node> nodes;
  ArrayList<PVector> relationships;

  Node selected;
  Node moving;

  float nodeSize;
  float textSize;

  boolean deleting;

  NHandler() {
    nodes = new ArrayList<Node>();
    NodeIDsCreated = 0;
    relationships = new ArrayList<PVector>();
    nodeSize = 75.0;
    textSize = nodeSize / 4.0;
    deleting = false;
  }

  void addNode(int numToAdd) {
    for (int i = 0; i < numToAdd; i++) {
      NodeIDsCreated++;
      nodes.add(new Node(this, 0, 0));
    }
  }

  void addNode(int numToAdd, int posx, int posy) {
    for (int i = 0; i < numToAdd; i++) {
      NodeIDsCreated++;
      nodes.add(new Node(this, posx, posy));
    }
  }

  boolean validID(int id) {
    boolean temp = false;
    for (Node n : nodes) {
      if (n.nodeID == id && n.valid) {
        temp = true;
        break;
      }
    }
    return temp;
  }

  void createRelationship(Node parent, Node child) {
    int pID = parent.nodeID;
    int cID = child.nodeID;
    if (pID != cID) {


      parent.children.add(cID);
      child.parents.add(pID);
      relationships.add(new PVector(pID, cID));
    }
  }

  void createOrRemoveRelationship(int parentID, int childID) {
    if (parentID != childID) {
      if (!containsRelationship(parentID, childID)) {
        getNodeByID(parentID).children.add(childID);
        getNodeByID(childID).parents.add(parentID);
        relationships.add(new PVector(parentID, childID));
      } else {
        breakSpecificRelationship(parentID, childID);
      }
    } else {
      println("Same ID (" + parentID + ", " + childID);
    }
  }

  Node getNodeByID(int nID) {
    Node temp = null;

    for (Node n : nodes) {
      if (n.nodeID == nID) return n;
    }

    return temp;
  }

  boolean containsRelationship(int parID, int chiID) {
    for (PVector r : relationships) {
      if (r.x == parID && r.y == chiID) {
        return true;
      }
    }
    return false;
  }

  void breakAllRelationshipsOfNode(Node n) {
    for (int i = relationships.size()-1; i >= 0; i--) {
      if (relationships.get(i).x == n.nodeID || relationships.get(i).y == n.nodeID) {
        int parID = int(relationships.get(i).x);
        int chiID = int(relationships.get(i).y);

        getNodeByID(parID).tryRemoveChild(chiID);
        getNodeByID(chiID).tryRemoveParent(parID);
        relationships.remove(i);
      }
    }
  }

  void breakAllRelationshipsOfNodeID(int nID) {
    for (int i = relationships.size()-1; i >= 0; i--) {
      if (relationships.get(i).x == nID || relationships.get(i).y == nID) {
        int parID = int(relationships.get(i).x);
        int chiID = int(relationships.get(i).y);

        getNodeByID(parID).tryRemoveChild(chiID);
        getNodeByID(chiID).tryRemoveParent(parID);
        relationships.remove(i);
      }
    }
  }

  void breakSpecificRelationship(int pID, int cID) {
    getNodeByID(pID).tryRemoveChild(cID);
    getNodeByID(cID).tryRemoveParent(pID);
    for (int i = relationships.size()-1; i >= 0; i--) {
      if (relationships.get(i).x == pID && relationships.get(i).y == cID) {
        relationships.remove(i);
      }
    }
  }

  void clearAllRelationships() {
    for (Node n : nodes) {
      breakAllRelationshipsOfNode(n);
    }
  }

  Node checkLeftClickingNode() {
    Node temp = null;

    float distance = width*height;
    int nID = 0;

    for (Node n : nodes) {
      if (dist(mouseX, mouseY, n.pos.x, n.pos.y) < distance) {
        distance = dist(mouseX, mouseY, n.pos.x, n.pos.y);
        nID = n.nodeID;
      }
    }

    if (distance <= nodeSize/2.0) {
      temp = getNodeByID(nID);
    }

    return temp;
  }

  void selectNode() {
    float distance = width*height;
    int nID = 0;

    for (Node n : nodes) {
      if (dist(mouseX, mouseY, n.pos.x, n.pos.y) < distance) {
        distance = dist(mouseX, mouseY, n.pos.x, n.pos.y);
        nID = n.nodeID;
      }
    }

    if (distance <= nodeSize/2.0) {
      selected = getNodeByID(nID);
    }
  }

  void processSelection() {
    if (selected == null) {
      selectNode();
    } else {
      tryStartRelationship();
      selected = null;
    }
  }

  void tryStartRelationship() {
    float distance = width*height;
    int nID = 0;

    for (Node n : nodes) {
      if (dist(mouseX, mouseY, n.pos.x, n.pos.y) < distance) {
        distance = dist(mouseX, mouseY, n.pos.x, n.pos.y);
        nID = n.nodeID;
      }
    }

    if (distance <= nodeSize/2.0) {
      createOrRemoveRelationship(selected.nodeID, nID);
      println(relationships);
    }
  }

  void render() {

    update();

    stroke(255);
    fill(0,0);
    for (PVector r : relationships) {
      PVector p1 = getNodeByID(int(r.x)).pos;
      PVector p2 = getNodeByID(int(r.y)).pos;
      PVector deltaP1 = new PVector(p2.x - p1.x, p2.y-p1.y).normalize().mult(nodeSize/2.0);
      PVector p1f = new PVector(p1.x+deltaP1.x, p1.y+deltaP1.y);
      float disty = dist(p1.x, p1.y, p2.x, p2.y)/2.0;
      float yOff = max(log(abs(p2.y - p1.y)+1)*disty,200);
      curve(p1f.x - deltaP1.x*5,  p1f.y - deltaP1.y*5, p1f.x, p1f.y, p2.x, p2.y-nodeSize/2.0, p2.x, p2.y + yOff);
    }

    stroke(0);
    for (Node n : nodes) {
      color fColor;
      if (n == selected) {
        fColor = color(0, 0, 255);
      } else {
        fColor = color(255);
      }
      n.show(fColor);
    }

    stroke(0);
    for (PVector r : relationships) {
      PVector p1 = getNodeByID(int(r.x)).pos;
      PVector p2 = getNodeByID(int(r.y)).pos;

      PVector arrow = new PVector(p2.x-p1.x, p2.y-p1.y).normalize().mult(nodeSize/2.0);

      line(p1.x, p1.y, p1.x+arrow.x, p1.y+arrow.y);
    }
  }

  void update() {
    if (deleting){
     deleteSelected();
    }
    if (moving != null) {
      moving.pos = new PVector(mouseX - (mouseX % (nodeSize/2.0)), mouseY - (mouseY % (nodeSize/2.0)));
    }
  }

  void pulseQTYs() {
    for (Node n : nodes) {
      n.pulseToChildren();
    }

    for (Node n : nodes) {
      n.trueQTY = n.reserveQTY1 + n.reserveQTY2;
      n.reserveQTY1 = 0;
      n.reserveQTY2 = 0;
    }
  }

  void clearQTYs() {
    for (Node n : nodes) {
      n.trueQTY = 0;
    }
  }

  void deleteSelected() {
    if (selected != null) {
      for (int i = nodes.size()-1; i>=0; i--) {
        if (selected.nodeID == nodes.get(i).nodeID) {
          println("deleting");
          breakAllRelationshipsOfNodeID(selected.nodeID);
          selected = null;
          nodes.remove(i);
          deleting = false;
          break;
        }
      }
    }
  }

  void scheduleDelete(){
    deleting = true;
  }
}

void mousePressed() {
  if (mouseButton == LEFT) {
    if (nodeHandler.checkLeftClickingNode() == null) {
      nodeHandler.addNode(1, mouseX, mouseY);
    } else {
      nodeHandler.moving = nodeHandler.checkLeftClickingNode();
    }
  }

  if (mouseButton == RIGHT) {
    nodeHandler.processSelection();
  }
}

void mouseReleased() {
  if (mouseButton == LEFT) {
    nodeHandler.moving = null;
  }
}

void keyPressed() {
  if (key == ' ') {
    nodeHandler.pulseQTYs();
  }
  if (key == 'c') {
    nodeHandler.clearQTYs();
  }

  if (key == DELETE) {
      println("Attempting Delete");
      nodeHandler.scheduleDelete();

  }
}