// Schwarzschild.

// Okay, this will let us drive a spaceship around a black hole. Here we go:

// first create an abstract object, since I guess we will in principle simulate more things. 
class thing {
  float r, phi, rdot, phidot;
  float s;
  
  float 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;
    s = 0;
    
    x = r*cos(phi);
    y = r*sin(phi);
  }
  
  void update() {
    // update the accel values, etc. 
     // GR version:
    rdot += ((r-rh)*pow(phidot,2) + pow(rdot,2)*(3*rh/(2*r*(r-rh))) - (rh*(r-rh))/(2*pow(r,3)))*deltaT;
    //rdot +=  (-G/pow(r,2)+ r*pow(phidot,2))*deltaT;
    phidot += (rdot*phidot*((3*rh - 2*r)/(r*(r-rh))))*deltaT;  
    
    r += (rdot*deltaT);
    phi += (phidot*deltaT);
    
    x = r*cos(phi);
    y = r*sin(phi);
    
    // update the proper time. 
    s += (1 - rh/r)*deltaT;

    
   
  }
  
}

// schwarzschild radius. 
float rh = 100;

float init_r = 300;
float init_phidot = 0.00137; 

// 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);
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 star_color = color(20,20,80);
color bg_color = color(0,0,60);

float rocketAcc = 0.01;

// overall thing for dimensional reasons. 

float deltaT = 0.5;


//float beep_rate = 500;
float beep_rate = 100;

float min_scale = 1;

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;

  
/* @pjs font="Arial.ttf"; */

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);
  
  // draw the background. 
  
  background(bg_color);
            // STEP 3 Specify font to be used
  fill(100,100,255);   
   
   // draw a few circles?
   
   /*
   int num_circles = 10;
   for (int i=0; i<num_circles; i++) {
     noFill();
     stroke(0,0,80);
     circle(0,0,2*((int)(rh+i*width/(2*num_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();
   
   // 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;
    
     // draw the background:
  
  
    // okay, next step: need to make this work with the time dilation. 
   
    float red_shift = sqrt(1-(rh/ship.r));
    
    // 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), red_shift*255);
    noStroke();
    
    // now see if we are firing rockets
    if (keyPressed) {
      if (keyCode == UP) {
        ellipse((int)(ship.r*cos(ship.phi)),(int)(ship.r*sin(ship.phi))+ship_width/2,jet_width,jet_width);
        vy -= rocketAcc;
      }
      if (keyCode == DOWN) {
        ellipse((int)(ship.r*cos(ship.phi)),(int)(ship.r*sin(ship.phi))-ship_width/2,jet_width,jet_width);
        vy += rocketAcc;
      }
      if (keyCode == LEFT) {
        ellipse((int)(ship.r*cos(ship.phi))+ship_width/2,(int)(ship.r*sin(ship.phi)),jet_width,jet_width);
        vx -= rocketAcc;
      }
      if (keyCode == RIGHT) {
        ellipse((int)(ship.r*cos(ship.phi))-ship_width/2,(int)(ship.r*sin(ship.phi)),jet_width,jet_width);
        vx += rocketAcc;
      }
      if (key == ENTER || key == RETURN) {
         ship.r = init_r;
         ship.phi = 0;
         ship.phidot = init_phidot;
         ship.rdot = 0;
         score = 0;
      }
      
      // now add them to the polar coordinate things! note the scaling by powers of the 
      // redshift; this is both to normalize the r coordinate and to make sure the impluse
      // delivered is finite in units of the rocket proper time. 
      
      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);
    } 
  
  // okay that seems to be working. now need to just write the real Schw stuff!
  

  // set color to the bh color . 
  fill(bh_color);
  //stroke(bh_color);
  //noFill();
  // draw the horizon:
  noStroke();
  ellipse(0,0,2*(int)rh,2*(int)rh);
  
  
  
 
  fill(red(ship_color), green(ship_color), blue(ship_color), max(red_shift,0.4)*255);


 
/* if (( (int)ship.s % (int)beep_rate) <= (beep_rate/4)) {
   //fill(200,0,50,max(red_shift*255,100));  
   fill(200,0,50);
//   stroke(255,0,50);
 }*/
 
 // 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)));
 
  // draw the ship
  ellipse((int)(ship.r*cos(ship.phi)),(int)(ship.r*sin(ship.phi)),ship_width,ship_width);
  
  fill(red(heart_color), green(heart_color), blue(heart_color), max(red_shift,0.4)*255);
  ellipse((int)(ship.r*cos(ship.phi)),(int)(ship.r*sin(ship.phi)),heartwidth,heartwidth);
  
  // draw the coin!
  fill(coin_color);
  ellipse((int)(coin.r*cos(coin.phi)),(int)(coin.r*sin(coin.phi)),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);
}