// Schwarzschild.

// Okay, this will let us drive a spaceship inside a black hole horizon

// first create an abstract object, since I guess we will in principle simulate more things. 
class thing {
  float r, phi, rdot, phidot, v, vdot;
  float display_r;
  float s;
  
  int x,y;
  
  // also keep track of x and y coords. 
  
  thing (float r_in, float phi_in, float rdot_in, float phidot_in) {
    
    // just initializes it. 
    r = r_in;
    phi = phi_in;
    rdot = rdot_in;
    phidot = phidot_in;
    
    display_r = r; 
    
    normalize();
    s = 0;
    v = 0;
  //  println(r, rdot, phi, phidot, vdot); 
    
    
    x = (int)(r*cos(phi));
    y = (int)(r*sin(phi));
  }
  
  void normalize() {
    // this is done differently depending on which side of the horizon we are on
    if (r > rh) {
      // figure out vdot by normalizing the whole thing to have length -1.
      vdot = (r*rdot + sqrt(r*(-rh+r*(1.0+pow(rdot,2)+(r*(r-rh)*pow(phidot,2))))))/(r-rh);
    }
    else {
      // now figure out rdot (as this is the timelike direction now)
      rdot = (-r + (r - rh)*pow(vdot,2)-pow(r,3)*pow(phidot,2))/(2*r*vdot);
      //rdot = 0;
    }
    
    float norm = 2*rdot*vdot + (-1 + rh/r)*pow(vdot,2) + pow(r*phidot,2);
    
    //println("norm ", norm, "normalizing: ", (-rh+r*(1.0+pow(rdot,2)+(r*(r-rh)*pow(phidot,2)))));
  }
  void update() {
    // update the accel values, etc. 
    // doing the eddington evolver:    
    vdot += (-(rh/(2*pow(r,2)))*pow(vdot,2) + r*(pow(phidot,2)))*deltaT;
    rdot += (((rh/pow(r,2))*rdot*vdot) - (((r-rh)*rh*pow(vdot,2))/(2*pow(r,3))) + ((r-rh)*pow(phidot,2)))*deltaT;
    phidot += (-(2*phidot*rdot)/r)*deltaT;
    
    // update the (r, phi, v) 
    r += (rdot*deltaT);
    phi += (phidot*deltaT);
    
    // only update the v if we have crossed the horizon (that way v = 0 is the horizon crossing time)
    if (r < rh) {
      v += (vdot * deltaT);
    }

    // finally, update the proper time. 
    s += deltaT;

    //float norm = 2*rdot*vdot + (-1 + rh/r)*pow(vdot,2) + pow(r*phidot,2);
    
    // next, figure out the display position. this is where we do an interesting nonlinear map. 
    
    // okay, here is the display position; use v as the coordinate after crossing horizon

    
    if (r > rh) {
      display_r = r;
    }
    else {
      display_r = rh/(1+v/v_scaling);
    }
      
    //float display_r = (exp(-v)*rh)*theta(rh-r) + theta(r-rh)*r;
    
    x = (int)(display_r*cos(phi));
    y = (int)(display_r*sin(phi));
    //println("v ", v, "display r", display_r, "r ", r);
   
  }
  
}

// schwarzschild radius. 
float rh = 300;
float UVcutoff = 5;
float v_scaling = 200;

float init_r = 1.6*rh;
float init_phidot = sqrt(rh)/(init_r*sqrt(2*init_r - 3*rh));

//float init_phidot = 0;

// create the ship. 
thing ship = new thing(init_r,0,0,init_phidot);

// create the coin
thing coin = new thing(init_r,1.5,0,init_phidot);

int ship_width = 30;
int jet_width = 10;
int coin_width = 20;

color jet_color = color(252,96,5); 
//color bh_color = color(137,203,242);
color bh_color = color(0,0,0,200);
color ship_color = color(181,195,203);
color coin_color = color(255,255,0);
color heart_color =  color(255,255,255);
color star_color = color(40,40,80);
color horizon_color = color(255,0,0,100);
//color star_color = color(20,20,80);
color bg_color = color(0,0,60);

float rocketAcc = 0.5;

// overall thing for dimensional reasons. 
float deltaT = 0.05;


float beep_rate = 20;
//float beep_rate = 100;
float wobble_amp = 400;

float min_scale = 0.75;

float T = 0; 
//float s = 0;  // proper time. 

// this is the number of timesteps that we go through before it displays it. 
// (40 is like arcade game. 20 is introspective enough that you can see things.) 
int display_rate = 30;

int score = 0;

PFont f;

// the star locations
int num_stars = 1000;

//int num_stars = 0;

int[] starsX = new int[num_stars];
int[] starsY = new int[num_stars];
int[] starSize = new int[num_stars];
int starMaxSize = 7;

// whether or not to show the horizon
boolean showHorizon = false; 

float tanh(float x) {
  return (exp(x) - exp(-x))/(exp(x) + exp(-x));
}

float theta(float x) {
  // this is a regulated step function for x > 0. 
  return (tanh(x/UVcutoff) + 1)/2;
}

void setup() {
  
  size(800,800);
  background(0,0,60);
  frameRate(30);


  for (int i =0; i<num_stars; i++) {
    starsX[i] = (int)random(-width,width);
    starsY[i] = (int)random(-width, width);
    starSize[i] = (int)(random(0.5,1)*starMaxSize);
  }

}

void draw() {

  // do the translation to put the origin at the center again: 
  translate(+width/2, +height/2);
  
  // okay, let's check -- if we are outside the edges, scale in
  
  min_scale = max(min(min_scale, width/(2*ship.r)),0.5);
  scale(min_scale);
  //scale(0.5);
  // draw the background. 
  
  background(bg_color);
  // STEP 3 Specify font to be used
  fill(100,100,255);   
   
   // draw a few circles?
   
   
   // draw a few stars? hard to tell what's better
   

   for (int i =0; i< num_stars; i++) {
     fill(star_color);
     ellipse(starsX[i], starsY[i], starSize[i],starSize[i]);
   }
   
  for (int i = 0; i<display_rate; i+=1) {
    
    // update them both
    
    ship.update(); 
    coin.update();
   
  //  println("r ", ship.r, "display r", ship.display_r); 
   // check if they have hit each other!

 // println(ship.x,coin.x,ship.y,coin.y);
   if (abs(ship.x-coin.x)<(ship_width/2) && abs(ship.y - coin.y)<(ship_width/2)) {
     score +=1;
     coin = new thing(init_r,random(6),0,init_phidot);
     
     fill(coin_color);
     ellipse(ship.x,ship.y,ship_width*2,ship_width*2);
     
   }
  }
  
   // create some cartesian variables
    float vx = 0;
    float vy = 0;
    
    // okay, next step: need to make this work with the time dilation. 
   
     // set color to the bh color . 
  
  fill(bh_color);
  
  // draw the center of the black hole:
  noStroke();
  //ellipse(0,0,2*(int)rh,2*(int)rh);
  ellipse(0,0,40,40);
  
  // draw the horizon if we want to
  if (showHorizon) {
    stroke(horizon_color);
    strokeWeight(5);
    noFill();
    ellipse(0,0,2*(int)rh,2*(int)rh);
  }
    
    float red_shift = 1;
    // set the amplitude of the thing based on the redshift
    //jet_color = color(red(jet_color), green(jet_color), blue(jet_color), sqrt(1-(rh/r))*255);
    fill(red(jet_color), green(jet_color), blue(jet_color));
    noStroke();
 // now drawing the ship: 

 if (ship.r == ship.r) {     
    // now see if we are firing rockets
    if (keyPressed) {
      if (keyCode == UP) {
        ellipse(ship.x,ship.y+ship_width/2,jet_width,jet_width);
        vy -= rocketAcc;
      }
      if (keyCode == DOWN) {
        ellipse(ship.x,ship.y-ship_width/2,jet_width,jet_width);
        vy += rocketAcc;
      }
      if (keyCode == LEFT) {
        ellipse(ship.x+ship_width/2,ship.y,jet_width,jet_width);
        vx -= rocketAcc;
      }
      if (keyCode == RIGHT) {
        ellipse(ship.x-ship_width/2,ship.y,jet_width,jet_width);
        vx += rocketAcc;
      }
      
 
      
      // okay, now need to figure out the thrust. this is a bit interestingly complicated
      // because of the eddington-finkelstein thing. note that i want to construct a radial 
      // outwards pointing vector with norm 1. this can be done as follows:
      
       ship.vdot += (cos(ship.phi)*vx + sin(ship.phi)*vy);
       ship.rdot += ((2*ship.r - rh)/(2*ship.r))*(cos(ship.phi)*vx + sin(ship.phi)*vy);
       
       // note that this will only hasten the descent into the madness
       
       // now this thing is the phidot. 
       
       ship.phidot +=((-sin(ship.phi)*vx + cos(ship.phi)*vy)/ship.r);
       
       // now finally normalize it again
        ship.normalize();
      //ship.rdot += pow((1-(rh/ship.r)),1.5)*(cos(ship.phi)*vx + sin(ship.phi)*vy);
      //ship.phidot +=(1-(rh/ship.r))*((-sin(ship.phi)*vx + cos(ship.phi)*vy)/ship.r);
      
    } // end keypressed
  
  // okay that seems to be working. now need to just write the real Schw stuff!
  

 
  
  


   // that makes sure ship is not NaN
    fill(red(ship_color), green(ship_color), blue(ship_color), max(red_shift,0.4)*255);

   // trying a new thing; a heartbeat! its size adapts dynamically with the proper time on the ship
   int heartwidth = (int) (ship_width*0.5*abs(sin(ship.s/beep_rate)));
 
   // also try a wibble-wobble coming from the tidal forces
   float tidal_factor_x = min(max(1, abs(sin(ship.s/beep_rate))*wobble_amp/ship.r),5);
   float tidal_factor_y = min(max(1, abs(cos(ship.s/beep_rate))*wobble_amp/ship.r),5);
  
  // float tidal_factor_x = min(max(1, abs(cos(ship.phi))*wobble_amp/ship.r),5);
  // float tidal_factor_y = min(max(1, abs(sin(ship.phi))*wobble_amp/ship.r),5);
    
   //float tidal_factor_y = min(max(1, abs(cos(ship.s/beep_rate))*wobble_amp/ship.r),5);
    ellipse(ship.x,ship.y,ship_width*tidal_factor_x,ship_width*tidal_factor_y);
    fill(red(heart_color), green(heart_color), blue(heart_color), max(red_shift,0.4)*255);
    ellipse(ship.x,ship.y,heartwidth,heartwidth);
 } 
 else {
   // hit singularity!
   fill(color(255,0,0));
   ellipse(0,0,ship_width,ship_width);
 }
 
 // finally, check for the restart:
 
 if (keyPressed) {
   if (key == ENTER || key == RETURN) {
         ship.r = init_r;
         ship.phi = 0;
         ship.phidot = init_phidot;
         ship.rdot = 0;
         ship.v = 0;
         score = 0;
         ship.normalize();
      }
 }
   
  // draw the coin!
  fill(coin_color);
  ellipse(coin.x,coin.y,coin_width,coin_width);
  
  // finally, draw the score:

   // draw the score. 
   for (int i=0; i< score; i++) {
     fill(coin_color);
     ellipse(-width/2+(coin_width*0.75*(i+1)),-height/2+20,coin_width*0.5,coin_width*0.5);
   }
  
  //println(1.0-(rh/r),cosTh,-(G/pow(r,2))*cosTh*deltaT,-(G/pow(r,2))*sinTh*deltaT, s, T);
  //println(ship.r, ship.phi, ship.s,ship.rdot,ship.phidot);
}

void keyPressed() {
    if (key == 'h') {
        showHorizon = !(showHorizon);
    }
    
}