PongPod.java

/**
 * PongPod.<br>
 * Play a pong with a wheel.<br><br>
 *
 * Copyright (C) 2005 Kenta Cho. Some rights reserved.
 * 
 * @p5 description
 * - 画面下の灰色の丸（ホイール）にカーソルを合わせてください
 * - クリックするとゲームが始まります
 * - ホイールに沿って丸くカーソルを動かすとラケットが動きます
 * - ラケットでボールをはじき返してください
 * - ボールが中央の黒丸に入るとミスです
 * - ミス3つでゲームオーバー
 */
//import processing.core.*;

//public class PongPod extends PApplet {
public class PongPod extends BApplet {
  Field field;
  Wheel wheel;
  Racket racket;
  Ball[] ball = new Ball[25];
  //PFont font;
  BFont font;
  int TITLE = 0;
  int IN_GAME = 1;
  int GAMEOVER = 2;
  int state;
  Title title;
  Gameover gameover;
  int score;
  Se se;

  public void setup() {
    size(340, 550);
    framerate(30);
    cursor(ARROW);
    noStroke();
    //
    ellipseMode(CENTER_DIAMETER);
    //font = loadFont("Verdana-48.vlw");
    font = loadFont("Futura-BoldCon.vlw.gz");
    textFont(font);
    field = new Field();
    field.init();
    wheel = new Wheel();
    wheel.init();
    racket = new Racket();
    racket.init();
    for (int i = 0; i < ball.length; i++)
      ball[i] = new Ball();
    title = new Title();
    gameover = new Gameover();
    se = new Se();
    se.load();
    startTitle();
  }

  void startTitle() {
    state = TITLE;
    title.start();
  }

  void startInGame() {
    state = IN_GAME;
    score = 0;
    se.init();
    initBalls();
    field.start();
    racket.start();
  }

  void startGameover() {
    state = GAMEOVER;
    gameover.start();
  }

  //public void draw() {
  public void loop() {
    background(250, 250, 250);
    smooth();
    switch (state) {
      case 0 : // TITLE
        field.draw();
        wheel.draw();
        wheel.move();
        title.draw();
        break;
      case 1 : // IN_GAME
        field.draw();
        wheel.draw();
        field.move();
        wheel.move();
        moveBalls();
        racket.move();
        racket.draw();
        drawBalls();
        drawStatus();
        se.playAllSes();
        break;
      case 2 : // GAMEOVER
        field.draw();
        wheel.draw();
        wheel.move();
        gameover.draw();
        drawStatus();
        break;
    }
  }

  void drawStatus() {
    textSize(26);
    //textAlign(RIGHT);
    textMode(ALIGN_RIGHT);
    fill(255, 255, 255);
    text(score, width - 14, 35);
  }

  float adjustDeg(float d) {
    if (d > PI)
      return d - PI * 2;
    else if (d < -PI)
      return d + PI * 2;
    else
      return d;
  }

  /**
   * 2D vector.
   */
  class Vector {
    float x, y;
  }

  /**
   * My racket.
   */
  class Racket {
    float SENSITIVITY = 0.7f;
    float radius;
    float deg;
    Vector[] pos;
    Vector p1, p2;
    float rWidth, rHeight;

    void init() {
      radius = field.bwRadius * 1.5f;
      pos = new Vector[2];
      for (int i = 0; i < pos.length; i++)
        pos[i] = new Vector();
      p1 = new Vector();
      p2 = new Vector();
      rWidth = 70;
      rHeight = 7;
    }

    void start() {
      deg = 0;
    }

    void move() {
      deg -= wheel.angVel * SENSITIVITY;
      deg = adjustDeg(deg);
      float d = deg;
      for (int i = 0; i < pos.length; i++) {
        pos[i].x = field.centerPos.x - sin(d) * radius;
        pos[i].y = field.centerPos.y + cos(d) * radius;
        p1.x = pos[i].x - sin(d + HALF_PI) * rWidth / 2;
        p1.y = pos[i].y + cos(d + HALF_PI) * rWidth / 2;
        p2.x = pos[i].x - sin(d - HALF_PI) * rWidth / 2;
        p2.y = pos[i].y + cos(d - HALF_PI) * rWidth / 2;
        for (int j = 0; j < ball.length; j++)
          if (ball[j].isExist)
            if (ball[j].checkHit(p1, p2))
              ball[j].reflectWithRacket(d + HALF_PI);
        d += PI;
      }
    }

    void draw() {
      fill(0, 0, 0);
      //rectMode(CENTER);
      rectMode(CENTER_DIAMETER);
      float d = deg;
      for (int i = 0; i < pos.length; i++) {
        //pushMatrix();
        push();
        translate(pos[i].x + field.pos.x, pos[i].y + field.pos.y);
        rotate(d);
        rect(0, 0, rWidth, rHeight);
        //popMatrix();
        pop();
        d += PI;
      }
      rectMode(CORNER);
    }
  }

  /**
   * Balls.
   */
  class Ball {
    Vector pos = new Vector();
    Vector ppos = new Vector();
    float deg;
    float speed;
    float size, trgSize;
    boolean isExist = false;
    int reflectCnt;
    int idx;

    void set(float x, float y, float d, float sp, float sz) {
      pos.x = x;
      pos.y = y;
      deg = adjustDeg(d);
      speed = sp;
      trgSize = sz;
      size = 0.1f;
      reflectCnt = 0;
      isExist = true;
    }

    void move() {
      ppos.x = pos.x;
      ppos.y = pos.y;
      pos.x -= sin(deg) * speed;
      pos.y += cos(deg) * speed;
      size += (trgSize - size) * 0.1f;
      if (pos.x < size || pos.x >= field.size.x - size)
        reflect(0);
      if (pos.y < size || pos.y >= field.size.y - size)
        reflect(HALF_PI);
      if (reflectCnt > 0)
        reflectCnt--;
      if (dist(pos.x, pos.y, field.centerPos.x, field.centerPos.y)
        < field.bwRadius * 0.75f + size) {
        field.incOutCnt();
        isExist = false;
        return;
      }
    }

    void reflect(float d) {
      float aod1 = abs(adjustDeg(deg - d));
      float aod2 = abs(adjustDeg(deg - (d + PI)));
      float od, aod;
      if (aod1 < aod2) {
        od = adjustDeg(deg - d);
        aod = aod1;
      } else {
        od = adjustDeg(deg - (d + PI));
        aod = aod2;
      }
      if (od < 0)
        deg += aod * 2;
      else
        deg -= aod * 2;
      pos.x = ppos.x;
      pos.y = ppos.y;
      pos.x -= sin(deg) * speed;
      pos.y += cos(deg) * speed;
      se.playSe(idx % 7);
    }

    void reflectWithRacket(float d) {
      if (reflectCnt <= 0) {
        reflect(d);
        se.playSe(7);
        score++;
      }
      reflectCnt = 3;
    }

    boolean checkHit(Vector p, Vector pp) {
      float bmvx, bmvy, inaa;
      bmvx = pp.x;
      bmvy = pp.y;
      bmvx -= p.x;
      bmvy -= p.y;
      inaa = bmvx * bmvx + bmvy * bmvy;
      if (inaa > 0.00001) {
        float sofsx, sofsy, inab, hd;
        sofsx = pos.x;
        sofsy = pos.y;
        sofsx -= p.x;
        sofsy -= p.y;
        inab = bmvx * sofsx + bmvy * sofsy;
        if (inab >= 0 && inab <= inaa) {
          hd = sofsx * sofsx + sofsy * sofsy - inab * inab / inaa;
          if (hd >= 0 && hd <= size * 0.7f + 7.0f) {
            return true;
          }
        }
      }
      return false;
    }

    void draw() {
      fill(255, 255, 255);
      ellipse(
        field.pos.x + pos.x,
        field.pos.y + pos.y,
        size * 2,
        size * 2);
    }
  }

  void initBalls() {
    for (int i = 0; i < ball.length; i++) {
      ball[i].idx = i;
      ball[i].isExist = false;
    }
    ballIdx = 0;
  }
  void moveBalls() {
    for (int i = 0; i < ball.length; i++)
      if (ball[i].isExist)
        ball[i].move();
  }
  void drawBalls() {
    for (int i = 0; i < ball.length; i++)
      if (ball[i].isExist)
        ball[i].draw();
  }
  int ballIdx = 0;
  Ball getBallInstance() {
    for (int i = 0; i < ball.length; i++) {
      if (!ball[ballIdx].isExist)
        return ball[ballIdx];
      ballIdx++;
      if (ballIdx >= ball.length)
        ballIdx = 0;
    }
    return null;
  }

  /**
   * Game field (main screen).
   */
  class Field {
    Vector pos = new Vector();
    Vector size = new Vector();
    float bwRadius;
    Vector centerPos = new Vector();
    float brightness;
    float bwSize;
    int cnt;
    int outCnt;

    void init() {
      size.x = 320;
      size.y = 240;
      pos.x = pos.y = (width - size.x) / 2;
      bwRadius = size.y * 0.1f;
      centerPos.x = size.x / 2;
      centerPos.y = size.y / 2;
      brightness = 0;
      bwSize = 1.0f;
    }

    void start() {
      bwSize = 1;
      cnt = 0;
      outCnt = 0;
      for (int i = 0; i < 3; i++)
        addBall();
    }

    void addBall() {
      Ball b = getBallInstance();
      if (b == null)
        return;
      float x, y;
      if (random(2) >= 1) {
        x = random(field.size.x - 40) + 20;
        if (random(2) >= 1)
          y = 20;
        else
          y = field.size.y - 20;
      } else {
        y = random(field.size.y - 40) + 20;
        if (random(2) >= 1)
          x = 20;
        else
          x = field.size.x - 20;
      }
      b.set(x, y, random(TWO_PI), 1.5f + random(1.0f), 4 + random(3.0f));
    }

    void incOutCnt() {
      se.playSe(8);
      outCnt++;
      if (outCnt >= 3)
        startGameover();
    }

    void move() {
      cnt++;
      if (cnt % 300 == 0)
        addBall();
    }

    void draw() {
      fill(80 * brightness, 200 * brightness, 80 * brightness);
      rect(pos.x, pos.y, size.x, size.y);
      fill(0, 0, 0);
      ellipse(
        pos.x + size.x / 2,
        pos.y + size.y / 2,
        bwRadius * 2 * bwSize,
        bwRadius * 2 * bwSize);
      if (state == IN_GAME) {
        fill(255, 255, 255);
        for (int i = 0; i < outCnt; i++)
          ellipse(
            pos.x + size.x / 2 - 10 + i * 10,
            pos.y + size.y / 2,
            10,
            10);
      }
    }
  }

  /**
   * Wheel that controls a racket.
   */
  class Wheel {
    Vector centerPos;
    float radFrom, radTo;
    boolean cursorOn;
    float angVel;
    float pdeg;

    void init() {
      centerPos = new Vector();
      centerPos.x = width / 2;
      centerPos.y = height * 0.75f;
      radFrom = width * 0.35f / 2;
      radTo = width * 0.7f / 2;
      cursorOn = false;
      angVel = 0;
      pdeg = 0;
    }

    void move() {
      float d = dist(mouseX, mouseY, centerPos.x, centerPos.y);
      if (d >= radFrom * 0.05f && d <= radTo * 1.4f) {
        if (!cursorOn) {
          cursorOn = true;
          cursor(HAND);
          pdeg = atan2(mouseX - centerPos.x, mouseY - centerPos.y);
        }
      } else {
        if (cursorOn) {
          cursorOn = false;
          cursor(ARROW);
        }
      }
      if (cursorOn) {
        float deg = atan2(mouseX - centerPos.x, mouseY - centerPos.y);
        angVel = adjustDeg(deg - pdeg);
        pdeg = deg;
      } else {
        angVel = 0;
      }
    }

    void draw() {
      fill(210, 210, 210);
      ellipse(centerPos.x, centerPos.y, radTo * 2, radTo * 2);
      fill(255, 255, 255);
      ellipse(centerPos.x, centerPos.y, radFrom * 2, radFrom * 2);
    }
  }

  /**
   * Title screen.
   */
  class Title {
    int cnt;

    void start() {
      cnt = 0;
      field.brightness = 0;
      field.bwSize = 0;
    }

    void draw() {
      cnt++;
      if (cnt > 30 && mousePressed && wheel.cursorOn) {
        startInGame();
        return;
      }
      if (cnt <= 30)
        field.brightness = cnt * (1.0f / 30);
      if (cnt > 45) {
        textSize(42);
        //textAlign(CENTER);
        textMode(ALIGN_CENTER);
        fill(255, 255, 255);
        text(
          "PongPod",
          field.pos.x + field.size.x / 2,
          field.pos.y + field.size.y / 2);
      }
    }
  }

  /**
   * Gameover screen.
   */
  class Gameover {
    int cnt;

    void start() {
      cnt = 0;
    }

    void draw() {
      cnt++;
      if (cnt > 300 || (cnt > 30 && mousePressed && wheel.cursorOn)) {
        startTitle();
        return;
      }
      if (cnt <= 30) {
        field.bwSize = 1.0f + cnt * 0.1f;
        field.brightness = 1.0f - cnt * (1.0f / 30);
      }
      if (cnt > 45) {
        textSize(32);
        //textAlign(CENTER);
        textMode(ALIGN_CENTER);
        fill(255, 255, 255);
        text(
          "GameOver",
          field.pos.x + field.size.x / 2,
          field.pos.y + field.size.y / 2);
      }
    }
  }

  /**
   * Sound effect.
   */
  class Se {
    int SE_NUM = 9;
    //PSound[] se;
    BSound[] se;
    boolean[] play;
    int cnt;
    int interval = 7;

    void load() {
      //se = new PSound[SE_NUM];
      se = new BSound[SE_NUM];
      play = new boolean[SE_NUM];
      for (int i = 0; i < SE_NUM; i++)
        se[i] = loadSound("se0" + (i + 1) + ".wav");
    }

    void init() {
      for (int i = 0; i < SE_NUM; i++)
        play[i] = false;
      cnt = 0;
    }

    void playSe(int n) {
      play[n] = true;
    }

    void playAllSes() {
      cnt++;
      int ci = cnt % interval;
      if (ci == interval - 1) {
        for (int i = 0; i < SE_NUM; i++) {
          if (play[i])
            //se[i].stop();
            stop(se[i]);
        }
      }
      if (ci == 0) {
        for (int i = 0; i < SE_NUM; i++) {
          if (play[i]) {
            //se[i].play();
            play(se[i]);
            play[i] = false;
          }
        }
      }
    }
  }
}