time_lines.pde

class TimeLines extends RunableSketch {
  final float min_vel = 20.0;
  final float max_vel = 50.0;
  
  final float min_length = 100;
  final float max_length = 500;
  
  final float min_chronoton_radius = 2.5;
  final float max_chronoton_radius = 7.5;
  
  final float delta_chronoton_radius = max_chronoton_radius - min_chronoton_radius;
  
  final float time_line_spawn_probability = 0.9;
  
  final float chronoton_spawn_probability = 0.4;
  
  class Chronoton {
    Vector direction;
    Vector pos;
    float v;
    
    TimeLine src_tl;
    
    color c;
    
    float t;
    
    boolean off_screen;
    
    public Chronoton(TimeLine src_tl) {
      this.src_tl = src_tl;
      
      Vector src_dir = src_tl.direction();
      
      this.direction = new Vector(src_dir.x-src_dir.y, src_dir.y+src_dir.x);
      
      Vector src_pos = src_tl.position();
      
      this.pos = new Vector(src_pos.x, src_pos.y);
      
      this.v = src_tl.velocity();
      
      this.c = src_tl.get_color();
      
      this.t = 0;
      
      this.off_screen = false;
    }
    
    public void update(float dt) {
      t += dt;
      float d = v*dt;
      
      pos.x += d*direction.x;
      pos.y += d*direction.y;
      
      if ((pos.x < 0) || (width < pos.x) || (pos.y < 0) || (height < pos.y)) {
        this.off_screen = true;
      }
    }
    
    public void draw() {
      float radius = min_chronoton_radius + delta_chronoton_radius*(1+ sin(t))/2;
      pushStyle();
        noStroke();
        fill(this.source().get_color());
        ellipse(pos.x, pos.y, 2*radius, 2*radius);
      popStyle();
    }
    
    public boolean is_off_screen() {
      return this.off_screen; 
    }
    
    public Vector position() {
      return pos;
    }
    
    public TimeLine source() {
      return src_tl;
    }
  }
  
  class TimeLine {
  
    Vector direction;
    Vector pos;
    Vector dim;
    float v;
    float l;
    
    color c;
  
    boolean off_screen;
    
    Chronoton chrono;
    
    Chronoton entangled_chrono;
    
    public TimeLine(Vector dir, float v, Vector pos, color c, float l, Vector dim) {
      this.direction = dir;
      this.pos = pos;
      this.dim = dim;
      this.c = c;
      this.v = v;
      this.l = l;
      
      off_screen = false;
      
      chrono = null;
      entangled_chrono = null;
    }
    
    public void update(float dt) {
      float d = this.velocity()*dt;
      pos.x += d*direction.x;
      pos.y += d*direction.y;
    }
    
    public void draw() {
      Vector end_pos = new Vector(pos.x - l*direction.x, pos.y - l*direction.y);
      //end_pos.x = max(0, end_pos.x);
      //end_pos.y = max(0, end_pos.y);
      
      //Vector start_pos = new Vector(min(pos.x, dim.x), min(pos.y, dim.y));
      Vector start_pos = new Vector(pos.x, pos.y);
      
      //print("" + start_pos.x + " " + start_pos.y + " " + end_pos.x + " " + end_pos.y + "\n");
      
      pushStyle();
        stroke(this.get_color());
        strokeWeight(2);
        line(end_pos.x, end_pos.y, start_pos.x, start_pos.y);
      popStyle();
      
      if ((width < end_pos.x) || (height < end_pos.y)) {
        off_screen = true;
      }
    }
    
    public boolean is_off_screen() {
      return this.off_screen;
    }
    
    private color get_color(TimeLine src) {
      if ((null != this.entangled_chrono) && (src != this.entangled_chrono.source())){
        return this.entangled_chrono.source().get_color(src);
      } else {
        return this.c;
      }    
    }
    
    public color get_color() {
      return this.get_color(this);
    }
    
    public Vector direction() {
      return this.direction;
    }
    
    public Vector position() {
      return this.pos;
    }
    
    private float velocity(TimeLine src) {
      if ((null != this.entangled_chrono) && (src != this.entangled_chrono.source())) {
        return this.entangled_chrono.source().velocity(src);
      } else {
        return this.v;
      }    
    }
    
    public float velocity() {
      return this.velocity(this);
    }
    
    public Chronoton spawn_chronoton() {
      this.chrono = new Chronoton(this);
      return this.chrono;
    }
    
    public boolean has_spawned_chronoton() {
      return (this.chrono != null);
    }
  
    private void entangle(Chronoton c, TimeLine src) {
      if ((null != this.entangled_chrono) && (this.entangled_chrono.source() != src)) {
        this.entangled_chrono.source().entangle(c, src);
      }
      this.entangled_chrono = c;
    }
    
    public void entangle(Chronoton c) {
      this.entangle(c, this);
    }
    
  
  }
  
  TimeLine random_time_line(int w, int h) {
      float d = sqrt(w*w + h*h);
      Vector direction = new Vector((float)w/d,(float)h/d);
      Vector position;
      Vector dimension = new Vector(w, h);
      
      int r = (int)random(0, w+h);
      
      r = r - (r%40);
      
      if (r < w) {
        position = new Vector(r, 0);
      } else {
        position = new Vector(0, r-w);
      }
      
      float l = random(min_length, max_length);
      float v = random(min_vel, max_vel);
      
      color c = color(random(255), random(255), random(255));
      
      /*
      println("d = "  + d);
      println("direction = " + direction.x + " " + direction.y);
      println("position = " + position.x + " " + position.y);
      println("dimension = " + dimension.x + " " + dimension.y);
      println("l = " + l);
      println("v = " + v);
      println("c = " + hex(c));
      */
      return new TimeLine(direction, v, position, c, l, dimension);    
  }
  
  ArrayList<TimeLine> tls;
  ArrayList<Chronoton> chronos;
  
  int last_millis;
  
  TimeLines() {
    tls = new ArrayList<TimeLine>();
    chronos = new ArrayList<Chronoton>();
    last_millis = millis();
  }
  
  int cnt = 0;

  float dt;

  void update(float dt) {
    this.dt = dt;
  }
  
  void draw() {
    cnt++;
    pushStyle();
      fill(255);
      noStroke();
      rect(0,0,width,height);
    popStyle();
    
    for (int i = 0; i < tls.size(); i++)
    {
      TimeLine tl = tls.get(i);
      
      tl.update(dt);
      tl.draw();
      
      if (tl.is_off_screen()) {
        tls.remove(i);
      } else {
        if (!tl.has_spawned_chronoton())
        {
          if (random(1) < dt*chronoton_spawn_probability) {
            //println("adding new chronoton.");
            Chronoton c = tl.spawn_chronoton();
            chronos.add(c);
          }
        }
      }
    }
    
    if (random(1) < (dt*time_line_spawn_probability)) {
      TimeLine tl = random_time_line(width, height);
      tls.add(tl);
      //println("count since last spawn: " + cnt);
      cnt = 0;
    }
    
    for (int i = 0; i < chronos.size(); i++)
    {
      Chronoton c = chronos.get(i);
      boolean remove = false;
      
      c.update(dt);
      c.draw();
      
      for (TimeLine tl : tls) {
        if (tl != c.source()) {
          if (vector_distance(tl.position(), c.position()) <= max_chronoton_radius) {
            //println("entangle!");
            tl.entangle(c);
            remove = true;
          }
        }
      }
      
      if (c.is_off_screen()) {
        remove = true;
      }
  
      if (remove) {
        chronos.remove(i);
      }    
    }
  }
}