Modify a text file: $/solarbam.pde

$/solarbam.pde

//// solarbam = KEY for CST-112 FINAL EXAM:   Planet class, Button class.
//
boolean bam=true; int many=8;

int numbuttons=5;
Button[] b=  new Button[numbuttons];
String bname[]= { 
  "size", "moons", "hours", "distance", "quit"
};
float buttonX=220, buttonY=400;

Planet[] yn = new Planet[8];

String[] namelist= { 
  "Mercury", "Venus", "Terra", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"
};
int mercury=0, venus=1, earth=2, mars=3, jupiter=4, saturn=5, uranus=6, neptune=7;

float[] orbitlist= { 0.387, 0.723, 1, 1.52, 5.20, 9.58, 19.20, 30.05, 39.48 };       // Orbital distance (AU)
float[] sizelist=  { 0.25, 0.95, 1, 0.45, 10, 7, 5, 5 };        // Multiple of Earth diameter.
float[] rholist=   { 5.427, 5.243, 5.514, 3.340, 3.933, 1.326, 0.687, 1.271, 1.638, 2.095 };  // Density.
float[] spinlist=  { 58.8, -244, 1, 27.4, 1.03, 0.415, 0.445, -0.720, 0.673, 6.41 };
float[] gravlist=  { 3.7, 8.9, 9.8, 1.6, 3.7, 23.1, 9.0, 8.7, 11.0, 0.7 };  //Gravity (m/s2)  
int[] moonlist=    { 0, 0, 1, 2, 67, 62, 27, 14, 5 };                            // Moons
boolean[] ringlist= { false, false, false, false, true, true, true, false };

void setup()
{
  size( 640, 480 );

yn[0]=  new Planet( 1, namelist[0] );
  yn[0].size=  0.25;
  //
  yn[1]=  new Planet( 2, namelist[1] );
  yn[1].size=  0.95;
  //
  yn[2]=  new Planet( 3, namelist[2] );
  yn[2].size=  1;
  yn[2].rho=  6;
  yn[2].moons=  1;
  //
  yn[3]=  new Planet( 4, namelist[3] );
  yn[3].size=  0.45;
  yn[3].moons=  2;

yn[4]=  new Planet( 5, namelist[4] );
  yn[5]=  new Planet( 6, namelist[5] );
  yn[6]=  new Planet( 7, namelist[6] );
  yn[7]=  new Planet( 8, namelist[7] );

//// ++++ REPLACE THE ABOVE LINES WITH A LOOP & ADD SOME NEW CONSTRUCTORS.. ++++

//// Buttons ////
  float x=buttonX, y=buttonY;

b[0]=  new Button();
  b[0].x=  buttonX+80;
  b[0].name=  "size";

for (int j=0; j<numbuttons; ++j) {
    x += 70;
    b[j]=  new Button( bname[j], x, y );
  }
  b[4].y=  height-40;          // Quit button at bottom corner.

//????
  //// ++++ REPLACE THE ABOVE LINES WITH A LOOP & ADD SOME NEW CONSTRUCTORS.. ++++

/*BAM*/
  if (bam)
  {
    for (int j=0; j<many; ++j)
    {
      yn[j]=  new Planet( j+1, namelist[j], orbitlist[j], sizelist[j], rholist[j], spinlist[j], moonlist[j], ringlist[j] );
    }
  }

// Force Mars red.
  yn[mars].r=  255;
  yn[mars].g =  60;
  yn[mars].b =  60;
}

void draw()
{
  background( 0, 0, 50 );
  
  text( "CST 112 FINAL:  Solar System Planets", width/3, 20 );
  text( "AUTHOR:  Prof. BAM", 20, height-5 );

showall();        // Display the planets.
  
  buttons();        // Buttons //

fill(255, 255, 100);
  text( "Sorting keys:  s, m, h, d", width/3, height-25 );
  fill( 255, 200, 200 );
  text( "  (Now, make the buttons work!)", width/3, height-10 );

flag( 20, height-120 );
}

void showall()
{

labels( 10, 40 );

if (bam) { bamplanets();   averages(570, 40); return;  }
    
  float x=80, y=40;
  yn[0].show( x, y );
  yn[1].show( x+60, y );
  yn[2].show( x+120, y );
  yn[3].show( x+180, y );
  // Do the same for planets 4, 5, 6, 7
  
  //// ++++ REPLACE THE ABOVE LINES WITH A LOOP & ADD YOUR NEW CODE HERE ++++

averages( x+490, 40 );
}

void buttons()
{
  float x=buttonX, y=height-60;
  text( "SORT BY:", x, height-60 );

if (bam) { bambuttons(); return; }

b[0].show();
 
  fill(0,255,0);  
  text( "Display the other buttons, too!", x+150, y );
  
}
void bambuttons()
{

for (int j=0; j<numbuttons; ++j )
  {
    b[j].show();
  }

}
void bamplanets()
{
  float x=80, y=40;
  for (int j=0; j<many; ++j )
  {
    yn[j].show(x,y);
    x += 60;
  }
}

void labels( float x, float y )
{
  // Name & properties.
  int next=15, line=0;
  fill(200);
  line++;
  text( "NAME:", x, y+next*line++ );
  text( "DISTANCE:", x, y+next*line++ );
  text( "SIZE:", x, y+next*line++ );
  text( "HOURS:", x, y+next*line++ );
  fill(255);
  text( "MOONS:", x, y+next*line++ );
}
void averages( float x, float y )
{
  // Name & properties.
  int next=15, line=0;
  fill(200);
  line++;
  text( "Averages:", x, y+next*line++ );
  //
  float total=0;
  for (int j=0; j<many; ++j) total += yn[j].size;
  text( total/many, x, y+next*line++ );

for (int j=0; j<many; ++j) total += yn[j].mass();
  text( total/many, x, y+next*line++ );

for (int j=0; j<many; ++j) 
  {
    float distance=  yn[j].distance;  
    total += distance * 30;
  }
  text( total/many, x, y+next*line++ );

for (int j=0; j<many; ++j) total += yn[j].spin;
  text( total/many, x, y+next*line++ );
}

//// Draw Coast Guard flag.
void flag( float x, float y )
{
  strokeWeight(6);
  stroke( 250, 200, 0 );
  fill( 255 );
  rect( x, y, 160, 100 );
  //
  stripes( x, y );
  strokeWeight(1);
  //
}
void stripes( float x, float y) {

// REMOVE THIS CODE AND REPLACE IT WITH YOUR OWN CODE, TO DRAW 13 STRIPES.

if (bam)  { bamstripes(x, y); return; }
  fill( 0 );
  text( "Draw a\n  Coast\n  Guard\n    Ensign here!", x+25, y+20 );
  fill( 0, 0, 255 );
  text( "(13 vertical stripes.)", x+25, y+80 );
  strokeWeight(1);
  stroke( 0 );
}

void bamstripes(float x, float y) {
  boolean red=false;
  noStroke();
  for (float xx=x; xx<x+150; xx+=160/13 ) {
    if (red) fill(255, 100, 0);
    else fill(255);
    red = ! red;
    rect(xx, y, 160/13, 100);
  }
}

//// EVENTS ////
void keyPressed()
{
  if (key == 's') sortSize( yn, many );
  if (key == 'd') sortDistance( yn, many );
  if (key == 'm') sortMoons( yn, many );
  if (key == 'h') sortHours( yn, many );
  if (key == 'q') exit();
}
void mousePressed()
{
  // ADD YOUR OWN CODE HERE.  +++++
}

//// CLASS DEFINITIONS:  Button, Planet
class Button {
  String name="";
  float x=200, y=400;

Button() {  };        // Default constructor //
  Button( String name, float x, float y ) {  this.name=name; this.x=x; this.y=y; }

void show()
  {
    fill(255, 255, 100);
    rect( x, y, 60, 30, 10 );
    fill(0);
    text( name, x+10, y+20);
  }
}

class Planet
{
  String name="";
  int orbit=1;
  float distance=1, size=1, rho=5, spin=24;
  int moons=0;
  boolean ring=false;
  int r, g, b;

//// CONSTRUCTORS ////
  Planet( int n, String name )
  {
    orbit=  n;
    this.name=  name;
    colorchange();
  }
  //// ++++ ADD NEW CONSTRUCTORS HERE ++++

//++++
  /**/
  Planet( int n, String name, float distance, float size, float rho, float spin, int moons, boolean ring )
  {
    orbit=  n;
    this.name=  name;
    this.distance=  distance;
    this.size=  size;
    this.rho=  rho;
    this.spin=  spin;
    this.moons=  moons;
    this.ring=  ring;
    colorchange();
  }

void colorchange()
  {
    // Random colors.
    r=  (int) random(150, 250);
    g=  (int) random(150, 250);
    b=  (int) random(150, 250);
  }

//// METHODS ////
  //// DISPLAY THE PLANET at (x,y):  Use size for size of circle.
  void show( float x, float y )
  {
    // Name & properties.
    int next=15, line=0;
    fill(r, g, b);
    text( orbit+".", x, y+next*line++ );
    text( name, x, y+next*line++ );
    text( distance, x, y+next*line++ );
    text( size, x, y+next*line++ );
    int hours=  (int) (24 * spin);
    text( hours, x+5, y+next*line++ );
    //
    fill(255);
    if (moons>0) text( moons, x+20, y+next*line++ );
    fill(r, g, b);
    // 
    //
    // Circle in column x, use orbit for y value.
    float xx=  x + 20;
    float yy=  y+next*line++;
    stroke( r, g, b );
    float yyy=  yy +  + orbit*20;
    line( xx, yy, xx, yyy );
    float diameter=  (float) Math.log(10*size) * 10;
    ellipse( xx, yyy, diameter, diameter );
    if (ring) {
      stroke( r, g, b );
      noFill();
      ellipse( xx, yyy, 1.5*diameter, 0.5*diameter );
    }
  }

float volume()
  {
    //// Volume is pi r-cubed. ////
    double radius=  size/2;
    double d=  Math.PI * Math.pow( radius, 3 );
    return (float) d;
  }
  float mass()
  {
    //// mass is volume times density. ////
    return rho * volume();
  }
}

void sortSize( Planet[] a, int many )
{
  for (int m=many; m>1; --m)
  {    
    // Move biggest to end, then shrink array.
    int w=  wSize( a, m );
    swap( a, m-1, w );
  }
}
int wSize( Planet[] a, int m )
{
  int w=0;
  for (int j=1; j<m; ++j)
  {
    // If this one is bigger, change w to point to it.
    if (a[j].size >= a[w].size) w=j;
  }
  return w;
}

void swap( Planet a[], int j, int k)
{
  Planet tmp=  a[j];
  a[j]=  a[k];
  a[k]=  tmp;
}

void sortDistance( Planet[] a, int many )
{
  for (int m=many; m>1; --m)
  {    
    // Move biggest to end, then shrink array.
    int w=  wDistance( a, m );
    swap( a, m-1, w );
  }
}

int wDistance( Planet[] a, int m )
{
  int w=0;
  for (int j=1; j<m; ++j)
  {
    // If this one is bigger, change w to point to it.
    if (a[j].distance >= a[w].distance) w=j;
  }
  return w;
}

//// ++++ BAM CODE:  REMOVE LATER!

void sortMoons( Planet[] a, int many )
{
  for (int m=many; m>1; --m)
  {    
    // Move biggest to end, then shrink array.
    int w=  wMoons( a, m );
    swap( a, m-1, w );
  }
}
int wMoons( Planet[] a, int m ) {
  int w=0;
  for (int j=1; j<m; ++j) { 
    if (a[j].moons >= a[w].moons) w=j;
  }    // If this one is bigger, change w to point to it.
  return w;
}

void sortHours( Planet[] a, int many ) {
  for (int m=many; m>1; --m) swap( a, m-1, wHours( a, m ) );    // Move biggest to end, then shrink array.
}
int wHours( Planet[] a, int m ) {
  int w=0;
  for (int j=1; j<m; ++j)  if (a[j].spin >= a[w].spin) w=j;   // If this one is bigger, change w to point to it.
  return w;
}