Modify a text file: $/billiards-1B30c.pde

$/billiards-1B30c.pde

//// Billiard table, with moving balls.
//// BAM 1B30c:  Demonstrate simple classes, constructors, array of objects.

//// Instantiate the balls.
Ball b1=  new Ball(color(255,0,0), 100,100);
Ball b2=  new Ball(color(255,255,0), 100,130);
Ball b3=  new Ball(color(0,0,200),  100,160);

Pocket[] tunnels=  new Pocket[6];

void setup() {
  //// Setup:  600x400 (for 300x500 table).
  size(600,400);
  ////  Initialize the pockets (and tunnel ends).
  tunnels[0]= new Pocket( 65,65, 335,65+20 );
  tunnels[1]= new Pocket( 65,335, 65,65+20 );
  tunnels[2]= new Pocket( 300,65, 300,335-20 );
  tunnels[3]= new Pocket( 300,335, 300,65+20 );
  tunnels[4]= new Pocket( 535,65, 535,335-20 );
  tunnels[5]= new Pocket( 535,335, 535,65+20 );
}
void initialize() {
  //// Randomize the ball positions.
  b1.x=100+random(100);  b1.y=100;
  b2.x=100+random(100);  b2.y=130;
  b3.x=100+random(100);  b3.y=160;
}
void keyPressed() {
  //// "R" restarts game.
  if (key=='R') {
    initialize();
  }
  //// "Q" quits game.
  if (key=='Q') {
    exit();
  }
}

void draw() {
  //// Table, with billiard balls.
  drawTable();
  moveBalls();
  drawBalls();
}
void  drawBalls() {
  //// Draw each ball.
  b1.show();
  b2.show();
  b3.show();
}

void  drawTable() {
  //// Draw 500x300 green light-table, with thick brown border, on tan backgroud.
  background( 200,150,100 );    // Tan floor.
  text( "BAM 1B30c:  Demonstrate classes, constructors, array of objects.", 25, 10);
  fill( 100,100,200);
  text( "(Ball tunnels when it goes into a pocket, and the table flashes its color).", 25, 30);
  fill( 0,0,200);
  text( "Press 'R' key to restart (randomly), 'Q' to quit.", 25, height-25);
  //// Table:
  fill( 100,200,100 );          // Light-green table.
  stroke( 100,50,50 );          // Brown (wood) rail.
  strokeWeight(25);
  rectMode(CORNER);
  rect(50,50, 500,300);        // Table (with rail);
  //// 6 pockets.
  for (int j=0; j<6; j++) {
    fill(0);
    tunnels[j].drawPocket();
  }

}

void  moveBalls() {
  //// Move each ball, based on its velocity (dx,dy),
  //// and detect hits.
  b1.move();
  b2.move();
  b3.move();
  //// Check for collisions.
  check(b1, b2);
  check(b1, b3);
  check(b2, b3);
  //// Check each pocket for tunneling (if a ball is in the pocket).
  for (int j=0; j<6; j++) {
    if (tunnels[j].inPocket(b1)) tunnels[j].wormhole(b1);
    if (tunnels[j].inPocket(b2)) tunnels[j].wormhole(b2);
    if (tunnels[j].inPocket(b3)) tunnels[j].wormhole(b3);
  }
}

void check( Ball p, Ball q) {
  //// Check for collisions; reverse both if hit.
  if (dist( p.x,p.y, q.x,q.y) < 10) {
    p.dx=  -p.dx;
    p.dy=  -p.dy;
    q.dx=  -q.dx;
    q.dy=  -q.dy;
    //// Eliminate "ringing" (by moving both in new direction.
    p.x += 2*p.dx;    p.y +=  2*p.dy;
    q.x += 2*q.dx;    q.y +=  2*q.dy;
    //// Also flash ball colors, and show text above.
    background(0);
    p.show();
    q.show();
    fill(255);
    text( "H I T !", p.x, p.y-20 );
    text( "HIT!", p.x, p.y );
    text( "HIT!", q.x, q.y );
  }
}

/////////////////  CLASSES

class Ball {
  //// Billiard ball.
  color c;
  float x=0,y=0;    // Position of this ball.
  float dx=10,dy=10;  // Velocity (pixels per frame).

//// CONSTRUCTORS ////
  Ball( float x0, float y0 ) {
    //// 2-arg constructor sets position only.
    x=  x0;
    y=  y0;
  }
  Ball( color c0, float x0, float y0 ) {
    //// 3-arg constructor sets color & position.
    c=  c0;
    x=  x0;
    y=  y0;
  }
  Ball( ) {
    //// Default constructor must be defined, if any others are defined!
  }

//// METHODS  ////
  void move() {
    //// Move ball by (dx,dy)
    x=  x + dx;
    y=  y + dy;
    // Bounce off walls.
    if (x < 75) {  dx=  -dx; }
    if (x > 525) {  dx=  -dx; }
    if (y < 75) {  dy=  -dy; }
    if (y > 325) {  dy=  -dy; }
  }
  void show() {
    //// Draw at (x,y)
    fill(c);
    //--  text(c, x, y+30);
    ellipseMode(CENTER);
    ellipse(x,y, 20,20);        // Diameter is 20.
  }
  void showBlack() {
    //// Draw at (x,y)
    fill(0);
    ellipseMode(CENTER);
    ellipse(x,y, 20,20);        // Diameter is 20.
  }
}

class Pocket {
  //// Pocket (tunnel);
  float x=0,y=0;    // Position of this pocket.
  float xx=0,yy=0;  // Position of tunnel end.
  //// CONSTRUCTOR(S);
  Pocket( float x0, float y0, float xx0, float yy0 ) {
    x=  x0;      y=  y0;
    xx=  xx0;    yy=  yy0;
  }
  //// METHOD(S)
  void drawPocket() {
    //// Draw a black pocket at (x,y).
    strokeWeight(0);
    ellipse( x,y, 30,30 );
  }
  boolean inPocket( Ball p ) {
    //// Return true if ball is in this pocket.
    return dist(p.x,p.y, x,y) < 20;
  }
  void wormhole( Ball p ) {
    //// Tunneling moves ball from (x,y) to (xx,yy)
    p.x=  xx;
    p.y=  yy;
    //// Also flash ball color.
    fill( p.c );
    drawPocket();
    //--    rect(50,50, 500,300);        // Table;
  }
}