• fullscreen
  • a.pde
  • w3__algorithm.pde
  • /*
    */
    Ball[] balls = new Ball[20];
    
    
    void setup() {
    
      size(1024, 768);
    
      smooth();
    
      // create balls with random coordinates and size
    
      for (int i = 0; i < balls.length; i++) {
    
        balls[i] = new Ball(random(width), random(height), random(10, 100));  
    
      }
    
    }
    
    void draw() {
    
      background(0);
    
      // draw balls
    
      for (int i = 0; i < balls.length; i++) {
    
        balls[i].display();
    
    
        // run a hit test on all other balls
    
        for (int n = 0; n < balls.length; n++) {
    
          if (n != i) {
    
            balls[i].hitTest(balls[n]);
    
    
          } 
    
    
    
        }
    
    
      }
    
    
      // check for mouse over
    
    
      for (int i = 0; i < balls.length; i++) {
    
        balls[i].onMouseOver(mouseX, mouseY);
    
      }
    
    
    }
    
    
    void keyPressed() {
    
      // when any key is pressed, propell balls outward to change the composition
    
    
      for (int i = 0; i < balls.length; i++) {
    
    
        balls[i].propell();
    
    
      }
    
    }
    
    
    class Ball {
    
      float x;
    
      float y;
    
      float r;
    
      float endX;
    
      float endY;
    
    
      float damping = 0.009;
    
      float spring = 0.10;
    
    
      boolean isHovered = false;
    
    
      Ball(float x_, float y_, float r_) {
    
    
        x = x_;
    
    
        y = y_;
    
    
        r = r_;
    
    
    
    
        // for gravitational pull toward the center, set endX and endY coordinates to center point
    
        endX = width/4;
    
        endY = height/4;
    
    
      }
    
    
      void display() {
    
    
    
        // increment end coordinates toward centerpoint
    
    
        endX = endX + (width/2 - endX) * damping;
    
    
        endY = endY + (height/2 - endY) * damping;
    
    
        // increment x and y coordinates
    
        x = x + (endX - x) * damping;
    
    
        y = y + (endY - y) * damping;
    
    
        if (!isHovered) {
    
    
          fill(50, 255);
    
    
        } else {
    
          fill(255);
    
        }
    
        noStroke();
    
        ellipse(x, y, r*2, r*2); 
    
    
      }
    
    
      void position(float x, float y) {
    
    
        endX = x;
    
    
        endY = y;
    
    
      }
    
    
      void hitTest(Ball ball) {
    
    
        float minDistance = ball.r + r;
    
    
    
        // if a hit test is registered, propell balls in the opposite direction 
    
    
        if (dist(ball.x, ball.y, x, y) < minDistance) {
    
    
    
          // first, get the difference between the two x, y coordinates
    
    
    
          float dx = ball.x - x;
    
          float dy = ball.y - y;
    
          /*
    
          next, calculate the angle in polar coordinates
    
    
          atan2 calculates the angle (in radians) from a specified point to the coordinate origin, 
    
          as measured from the positive x-axis. more info here: http://processing.org/reference/atan2_.html
    
          */
    
          float angle = atan2(dy, dx);
    
    
          // now, calculate the target coordinates of the current ball by using the minimum distance
    
    
          float targetX = x + cos(angle) * minDistance;
    
    
          float targetY = y + sin(angle) * minDistance;
    
    
          // increment the x and y coordinates for both objects
    
          x = x - (targetX - ball.x) * spring;
    
    
          y = y - (targetY - ball.y) * spring;
    
          ball.x = ball.x + (targetX - ball.x) * spring;
    
    
          ball.y = ball.y + (targetY - ball.y) * spring;
    
    
    
        } 
    
    
    
      }
    
    
      void propell() {
    
        // randomize angle relative to sketch center
    
        float angle = random(360);
    
    
        // increment endX and endY coordinates
    
        endX = x - cos(angle) * height/2;
    
        endY = y - sin(angle) * height/2;
    
      }
    
      void onMouseOver(float mx, float my) {
    
    
        if (dist(mx, my, x, y) < r) {
    
          isHovered = true;
    
        } 
    
    
        else {
    
          isHovered = false; 
    
    
        }
    
    
      }
    
    }
    
    

    code

    tweaks (0)

    about this sketch

    This sketch is running as Java applet, exported from Processing.

    license

    advertisement

    yaphawping

    w3__algorithm

    Add to Faves Me Likey@!
    You must login/register to add this sketch to your favorites.

    You need to login/register to comment.