Modify a text file: $/bumping-energy.java

$/bumping-energy.java

//// bumping-energy.java (bam CST112):  Use an array of objects.

Zoog[] z=  new Zoog[10];    // Make room for (up to) ten Zoogs.
int many=10;
int debug=0;
boolean energyShow=false;
float sayX=500, sayY=50, sayN=0;

void setup()
{
  size( 800,600);
  smooth();
  z=  new Zoog[10];
  populate( many );
  //--  frameRate(5);
}
void populate( int m)    // Populate the array with a random number of (up to ten) Zoogs.
{
  many=  m;
  for (int i=0; i<many; i++)
  {
    // One randomly-placed Zoog, approx 50x80
    z[i]=  new Zoog( i, 20+random(0,width-50), random(0,height-80) );
    z[i].ranspeed();
    z[i].ransize();
    z[i].c=  color( 25*i, 255-25*i, random(255) );
  }
}

void draw()    // Draw scene and critters.
{
  sayN=0;
  background( 250,255,200 );
  scene();
  critters();
  if (energyShow) energy();
  if (key == '?')  help();
}
void scene()
{
  text( many, 75, 20); 
  text( "C O L L I D I N G     Z  O  O  G  S", 100, 20); 
  text( " (Zoogs gain or lose by colliding.)", 100, 36); 
  text( "       Hold ? key for help", 100, 48); 
}
void critters()      // Move and draw each critter.
{
  for (int i=0; i<many; i++)
  {
    z[i].move();
    for ( int j=i+1; j<many; j++)              // Check all possible collisions.
    {
      z[i].collide( z[j] );                    // Handle each collision (if it occurs)
    }
    //// Now draw all Zoogs.
    z[i].draw();
  }
}

void keyPressed()        // Check which key
{
  if (key == 'r') 
  {
    many=  1 + (int) (random(10));
    populate( many );
  }
  if (key == 'd') debug++;
  if (key == 'D') debug=0;  
  if (key == 's') frameRate(frameRate-5);    // Slow
  if (key == 'S') frameRate(30);             // Speedup again.
  if (key == 'e') energyShow=true;  
  if (key == 'E') energyShow=false;  
  // Speedup/slowdown
  int k;
  if (key == '+')                // Increase all speeds.
  {    for (k=0; k<many; k++)  { z[k].dx++; z[k].dy++; }  }
  if (key == '-')                // Decrease all speeds.
  {    for (k=0; k<many; k++)  { z[k].dx--; z[k].dy--; }  }
  if (key == '=')                // Reset all speeds.
  {
    for (k=0; k<many; k++) 
    {
        z[k].dx=  3;
        z[k].dy=  2;
    }
  }
  k=  (int) key - 48;
  if (k>=0 && k<many)
  {
    z[k].dx++;
    z[k].dy++;
  }
}
void mousePressed()    // Move Zoog 0 here!
{
  z[0].x=  mouseX;
  z[0].y=  mouseY;
}
void help()
{
  say("r   repopulate (random # of new Zoogs).");
  say("0-9 speed up one Zoog");
  say("+   speed up ALL Zoogs");
  say("-   slow down ALL Zoogs");
  say(" =  reset all speeds.");
  say("");
  say("");  say(" E/e  display energy, etc.");
  say("d/D debugging on / off ");
  say("s/S frameRate slower/fastest");
  say("");
}
void energy()          // Calculate the total and average kinetic energy.
{
  float e=0, v=0, p=0, mass=0;
  float eavg=0, vavg=0, pavg=0, massavg=0;
  for (int i=0; i<many; i++ )
  {
    mass += z[i].mass();
    v += z[i].velocity();
    e += z[i].energy();
    p += z[i].mass() * z[i].velocity();
  }
  ////
  sayX=400; sayY=100; sayN=0;
  say("");
  say( "ENERGY:");
  say( "MOMENTUM:");
  say( "MASS:");
  say( "VELOCITY:");

sayX=500; sayY=100; sayN=0;
  say("TOTAL:");
  say(""+e);
  say(""+p);
  say(""+mass);
  say(""+v);
  
  eavg=  e/many;
  massavg=  mass/many;
  vavg=  v/many;
  pavg=  p/many;
  
  sayX=600; sayY=100; sayN=0;
  say("AVG:");
  say(""+eavg);
  say(""+pavg);
  say(""+massavg);

}

//// OTHER METHODS (Not part of a class.
void say(String s)    // Write text to next available line.
{
  text( s, sayX, sayY + 12*sayN++ );
}
boolean hit( float near, float x, float y,   float xx, float yy)
{
  //// Check for hit:  return true if (x,y) near (xx,yy)
  return abs(x-xx) < near && abs(y-yy) <near;
}

//////// CLASS DEFINITIONS ////////
class Zoog
{
  // PROPERTIES:
  float x=width/2, y=height/2, dx=3, dy=2;     // Position and speed of this one.
  float w=30, h=60;                            // Width and height of this Zoog.
  color c=color(150+random(100),150,0), t=color(0,0,150+random(100));    // Colors of body and text.
  int num;                                     // Number (for text on body)
  
  int counter=0;
  
  // CONSTRUCTORS:
  Zoog( int numset, float xset, float yset, float dxset, float dyset, float wset, float hset )
  {
    //// 7-arg Constructor, to set everything (except color).
    num=numset; 
    w= wset;
    h=  hset;
    x= yset; 
    y= yset;
    dx= dxset; 
    dy= dyset;
  }
  Zoog()       // Default constructor -- num=0 and use all defaults.
  {
  }
  Zoog( int numset ) 
  { 
    num=numset; ransize(); ranplace(); ranspeed(); }
  Zoog( int numset, float xset, float yset )//  sets only num and (x,y).
  {
    num=numset; 
    x= yset; 
    y= yset;
    ranspeed(); 
    ransize(); 
  }
  /// Randomize.
  void ranplace()  {  x= random(width); y=random(height);  }
  void ransize()  {  w=  20 + random(10); h=  30 + random(10);  }
  void ranspeed()
  {
    //// Random speeds.
    dx=  8 - (int) random(16);
    dy=  6 - (int) random(12);
  }
    
  
  //// Zoog class METHODS:  ////
  void draw()            // Draw the Zoog.
  {
    fill( c);    
    rectMode(CORNER);
    rect( x, y, w+counter, h+counter );        // Zoog grows with counter
    fill(t);
    text( num, x+w/4, y+h/2);    // Display # in middle of rect.
    if (counter>0)  {
      text( counter, x+w/4, 12 + y+h/2);    // Display hit count, underneath
    }
    // (Debugging:  display coords.)
    if (debug>0)
    {  
      fill(0,0,255);
      text( x, x+30+w/4, 12 + y+h/2);
      text( y, x+30+w/4, 24 + y+h/2);
    }
  }
  float mass()          // Calculate the mass of this Zoog.
  {
    return 0.001 * (w+counter) * (h+counter);        // Kilograms = width * height
  }
  float velocity()      // Calculate the velocity of this Zoog
  {
    return sqrt( sq(dx) + sq(dy) );
  }
  float energy()        // Caclulate the kinetic energy = (1/2) m v^2
  {
    return 0.5 * mass() * sq( velocity() );
  }
  void move()            // Move to new (x,y)
  {
    x += dx;            // Move one unit.
    y += dy;
    // Check for walls.
    if (x>width-10  ||   x<20)        // Reverse direction, if off sides.
    {
      dx = -dx;
      x += 3*dx;        // Bounce (to avoid jiggle at edge).
    }
    if (y>height-10  ||   y<10)        // Reverse direction, if beyond top or bottom.
    {
      dy = -dy;
      y += 3*dy;        // Bounce (to avoid jiggle at edge).
    }
    //// Keep Zoogs from fluttering on the walls!
    if (x < 0) x=10;
    if (x > width) x=width-10;
    if (y < 0) y=10;
    if (y > height) y=height-10;
  }
  void collide( Zoog other)    // Return true iff collision with other.
  {
    if ( hit( 50, other.x, other.y,  this.x, this.y) )
    {
      // Flash  two circles!
      stroke(255,0,0);  strokeWeight(2);
      fill(this.c);  ellipse(x-2*dx, y-2*dy, 30,30);
      fill(other.c);  ellipse(other.x, other.y, 30,30);
      strokeWeight(1);  stroke(0);

// exchange velocities & bounce apart.
      float tmp;
      tmp=  other.dx;      other.dx=  this.dx;      this.dx=  tmp;
      x += 10*dx;
      tmp=  other.dy;      other.dy=  this.dy;      this.dy=  tmp;
      y += 10*dy;
      // Also bump both counters.
      if (this.x < other.x) 
      {
        this.counter++;
        other.counter--;
      } else {
        this.counter--;
        other.counter++;
      }
    }
  }
}