RallX.java

/**
 * Rallx.<br>
 *  迷路脱出ゲームレーダー付き<br><br>
 *
 * Copyright 2004 Kenta Cho. All rights reserved.
 * 
 * @p5 description
 * -車をマウスで操作して、全ての旗を回収、迷路の中央の出口に向かってください。
 * -Control a car with your mouse, get all flags and go to the exit at the center of the maze.
 * -赤い岩にぶつかると車を失います。
 * -Avoid red square shaped rocks. You lose a car when you crash into a rock.
 * -マウスボタンを押しっぱなしでレーダーを見られます。迷路全体を見渡すことができますが、岩は表示されません。
 * -Hold a mouse button to see the radar screen. You can see the entire maze but rocks are not shown on the radar.
 * -画面下にある残り時間がなくなっても車を失います。
 * -You also lose a car when a time(displayed at the bottom of screen) runs out.
 */
public class RallX extends BApplet {
  /**
   * 迷路データ（0-空、1-壁、2-ゴール、3-旗、10〜-岩）
   */
  int[][] maze;
  /**
   * 迷路や出口の大きさ用定数
   */
  int MAZE_SIZE = 49, EXIT_SIZE = 7;
  /**
   * 迷路1ブロックのレーダー上の大きさ
   */
  int mazeRectSize;
  /**
   * 迷路1ブロックのスクロール画面上の大きさ
   */
  float mazeWallSize;
  /**
   * 出口の方向
   */
  int exitD;

  /**
   * スクロール画面内に表示するブロック数
   */
  int wallSightRange;
  /**
   * 自車関連データ
   */  
  float cx, cy, cd, cmd, cmx, cmy, csp, cmsp;
  /**
   * 自車のいるブロック位置
   */
  int wx, wy;
  /**
   * レーダー切り替え時カウンタ
   */
  int rcnt;
  /**
   * レーダー切り替え時アルファ値
   */
  int ca;
  /**
   * ラウンドクリア時カウンタ
   */
  int ccnt;
  /**
   * 自車クラッシュ時カウンタ
   */
  int dcnt;
  /**
   * 画面中央に表示するメッセージ
   */
  String msg;
  /**
   * メッセージ用カウンタ
   */
  int mcnt;

  /**
   * パーティクルの最大数
   */
  int PARTICLE_NUM = 32;
  /**
   * パーティクルインスタンスプール
   */
  Particle[] particle;
  /**
   * 岩の最大数
   */
  int ROCK_NUM = 50;
  /**
   * 岩インスタンスプール
   */
  Rock[] rock;
  /**
   * 残りの旗の数
   */
  int flagNum;
  /**
   * ステージ数
   */
  int stage;
  /**
   * スコア
   */
  float score;
  /**
   * 残機数
   */
  int left;
  /**
   * 残り時間
   */
  int time;
  /**
   * ゲーム状態用定数
   */
  int TITLE = 0, IN_GAME = 1;
  /**
   * ゲームの状態（タイトル／ゲーム中）
   */
  int state;
  /**
   * 各面のスタート時の残り時間（30frame * 60sec）
   */
  int STAGE_TIME = 1800;

  /**
   * フォントデータ
   */
  BFont font;
  /**
   * BGMデータ
   */
  BSound bgm;
  /**
   * SEデータ
   */
  BSound flagSe, crashSe, clearSe;

  /**
   * 初期化（フォント、サウンド読み込み、インスタンス生成）
   */
  void setup() {
    size(300, 300);
    framerate(30);
    smooth();
    cursor();
    ellipseMode(CENTER_DIAMETER);
    font = loadFont("OCR-A.vlw.gz");
    textFont(font);
    bgm = loadSound("bgm.wav");
    flagSe = loadSound("flag.wav");
    crashSe = loadSound("crash.wav");
    clearSe = loadSound("clear.wav");

    mazeRectSize = width / MAZE_SIZE;
    maze = new int[MAZE_SIZE][MAZE_SIZE];
    mazeWallSize = 40;
    wallSightRange = (int) (width / mazeWallSize) / 2 + 2;

    particle = new Particle[PARTICLE_NUM];
    for (int i = 0; i < particle.length; i++)
      particle[i] = new Particle();
    rock = new Rock[ROCK_NUM];
    for (int i = 0; i < rock.length; i++)
      rock[i] = new Rock();

    startTitle();
  }

  /**
   * タイトル初期化
   */
  void startTitle() {
    state = TITLE;
    stop(bgm);
    exitD = 0;
    stage = 0;
    left = 0;
    initStage();
    ca = 150;
    time = -999;
    float d = random(PI * 2);
    cmx = sin(d);
    cmy = cos(d);
    mcnt = 0;
  }

  /**
   * ゲーム開始
   */
  void startGame() {
    state = IN_GAME;
    exitD = 0;
    stage = -1;
    score = 0;
    left = 2;
    initStage();
    volume(bgm, 1.0f);
    jump(bgm, 0);
    repeat(bgm);
  }

  /**
   * ステージ生成
   */
  void initStage() {
    // Init a car potision.
    switch (exitD) {
      case 0 :
        cx = MAZE_SIZE * mazeWallSize / 2;
        cy = mazeWallSize * 1.5f;
        cd = PI;
        break;
      case 1 :
        cx = MAZE_SIZE * mazeWallSize - mazeWallSize * 1.5f;
        cy = MAZE_SIZE * mazeWallSize / 2;
        cd = PI / 2 * 3;
        break;
      case 2 :
        cx = MAZE_SIZE * mazeWallSize / 2;
        cy = MAZE_SIZE * mazeWallSize - mazeWallSize * 1.5f;
        cd = 0;
        break;
      case 3 :
        cx = mazeWallSize * 1.5f;
        cy = MAZE_SIZE * mazeWallSize / 2;
        cd = PI / 2;
        break;
    }
    cmx = cmy = 0;
    csp = 0;
    rcnt = 0;
    ccnt = -8;
    dcnt = 0;
    time = STAGE_TIME;

    // Set a stage pattern.
    stage++;
    int rockNum = 0;
    switch (stage % 6) {
      case 0 :
        mazeGrid = 8;
        mazePtn = 0;
        rockNum = stage * 3;
        flagNum = 4;
        break;
      case 1 :
        mazeGrid = 4;
        mazePtn = 0;
        rockNum = stage - 1;
        flagNum = 0;
        break;
      case 2 :
        mazePtn = 1;
        rockNum = 10 + stage * 4;
        flagNum = 8;
        break;
      case 3 :
        mazeGrid = 6;
        mazePtn = 0;
        rockNum = stage * 3;
        flagNum = 4;
        break;
      case 4 :
        mazeGrid = 3;
        mazePtn = 0;
        rockNum = stage;
        flagNum = 0;
        break;
      case 5 :
        mazeGrid = 6;
        mazePtn = 2;
        rockNum = 12 + stage * 3;
        flagNum = 3;
        break;
    }
    if (rockNum > rock.length)
      rockNum = rock.length;
    if (stage == 0) {
      msg = "Get flags.";
      mcnt = 60;
    } else if (stage == 2) {
      msg = "Avoid rocks.";
      mcnt = 60;
    } else if (flagNum == 0) {
      msg = "Go to the exit.";
      mcnt = 60;
    } else {
      mcnt = 0;
    }

    // Create a maze and set flags and rocks.
    createMaze();
    wx = (int) (cx / mazeWallSize);
    wy = (int) (cy / mazeWallSize);
    maze[wx][wy] = 1;
    for (int i = 0; i < flagNum; i++) {
      int x, y;
      do {
        x = (int) random(MAZE_SIZE - 2) + 1;
        y = (int) random(MAZE_SIZE - 2) + 1;
      } while (maze[x][y] != 0);
      maze[x][y] = 3;
    }
    for (int i = 0; i < rockNum; i++) {
      int x = (int) random(MAZE_SIZE - 2) + 1;
      int y = (int) random(MAZE_SIZE - 2) + 1;
      if (maze[x][y] == 0) {
        maze[x][y] = i + 10;
        rock[i].ox = random(mazeWallSize / 2) + mazeWallSize / 4;
        rock[i].oy = random(mazeWallSize / 2) + mazeWallSize / 4;
        rock[i].x = x * mazeWallSize + rock[i].ox;
        rock[i].y = y * mazeWallSize + rock[i].oy;
      }
    }
    maze[wx][wy] = 0;
  }

  /**
   * 迷路の壁と壁の間隔
   */
  int mazeGrid;
  /**
   * 迷路パターン（0-通常、1-なにもなし、2-うずまき）
   */
  int mazePtn;
  /**
   * 壁を延ばした地点の数（迷路作成終了判定用）
   */
  int pointNum;
  /**
   * 壁を延ばしている座標
   */
  int stx, sty, std;
  /**
   * 壁を延ばす方向の移動量定数
   */
  int[] DMX = { 0, 1, 0, -1 }, DMY = { -1, 0, 1, 0 };
  /**
   * うずまき型迷路作成用カウンタ
   */
  int turnCnt;

  /**
   * 壁を延ばして迷路作成
   */
  void createMaze() {
    for (int x = 0; x < MAZE_SIZE; x++)
      maze[x][0] = maze[x][MAZE_SIZE - 1] = 1;
    for (int y = 1; y < MAZE_SIZE - 1; y++) {
      maze[0][y] = maze[MAZE_SIZE - 1][y] = 1;
      for (int x = 1; x < MAZE_SIZE - 1; x++)
        maze[x][y] = 0;
    }
    int ep = (MAZE_SIZE - EXIT_SIZE) / 2;

    int bn = 0;
    switch (mazePtn) {
      case 0 :
        bn = 100;
        pointNum = MAZE_SIZE / mazeGrid;
        pointNum -= 1;
        pointNum *= pointNum;
        pointNum -= (int) ((EXIT_SIZE + 1) / mazeGrid)
          * (int) ((EXIT_SIZE + 1) / mazeGrid);
        break;
      case 1 :
        bn = 0;
        pointNum = 0;
        break;
      case 2 :
        bn = 1;
        pointNum = 999;
        turnCnt = 0;
        break;
    }
    for (int i = 0; i < bn; i++) {
      if (pointNum <= 0)
        break;
      if (mazePtn == 0) {
        stx =
          (int) random((MAZE_SIZE - 1) / mazeGrid - 1) * mazeGrid
            + mazeGrid;
        sty =
          (int) random((MAZE_SIZE - 1) / mazeGrid - 1) * mazeGrid
            + mazeGrid;
        std = (int) random(4);
        if (maze[stx][sty] == 1) {
          if (!moveTillNoWall())
            continue;
        } else {
          if (!moveTillWall())
            continue;
        }
      } else {
        switch (exitD) {
          case 0 :
            stx = ((int) (MAZE_SIZE / mazeGrid) / 2 + 1) * mazeGrid;
            sty = 0;
            std = 2;
            break;
          case 1 :
            stx = MAZE_SIZE - 1;
            sty = ((int) (MAZE_SIZE / mazeGrid) / 2 + 1) * mazeGrid;
            std = 3;
            break;
          case 2 :
            stx = ((int) (MAZE_SIZE / mazeGrid) / 2 - 1) * mazeGrid;
            sty = MAZE_SIZE - 1;
            std = 0;
            break;
          case 3 :
            stx = 0;
            sty = ((int) (MAZE_SIZE / mazeGrid) / 2 - 1) * mazeGrid;
            std = 1;
            break;
        }
      }
      createMazeBranch();
    }

    // Create the exit hole.
    fillMaze(ep - mazeGrid + 1, EXIT_SIZE + (mazeGrid - 1) * 2, 0);
    fillMaze(ep, EXIT_SIZE, 1);
    fillMaze(ep + 1, EXIT_SIZE - 2, 2);
    exitD = (int) random(4);
    int ex, ey;
    switch (exitD) {
      case 0 :
      case 2 :
        ex = ep + 2;
        if (exitD == 0)
          ey = ep;
        else
          ey = ep + EXIT_SIZE - 1;
        for (int x = ex; x < ex + EXIT_SIZE - 4; x++)
          maze[x][ey] = 0;
        break;
      default :
        ey = ep + 2;
        if (exitD == 3)
          ex = ep;
        else
          ex = ep + EXIT_SIZE - 1;
        for (int y = ey; y < ey + EXIT_SIZE - 4; y++)
          maze[ex][y] = 0;
        break;
    }
  }

  /**
   * 壁がない地点まで移動（壁延ばし開始地点探索用）
   * @return 地点が見つかった
   */
  boolean moveTillNoWall() {
    int tx = stx, ty = sty;
    for (;;) {
      tx += DMX[std] * mazeGrid;
      ty += DMY[std] * mazeGrid;
      if (tx < 0 || tx >= MAZE_SIZE || ty < 0 || ty >= MAZE_SIZE)
        return false;
      if (maze[tx][ty] == 0)
        return true;
      stx = tx;
      sty = ty;
    }
  }
  /**
   * 壁がある地点まで移動（壁延ばし開始地点探索用）
   * @return 地点が見つかった
   */  
  boolean moveTillWall() {
    for (;;) {
      stx -= DMX[std] * mazeGrid;
      sty -= DMY[std] * mazeGrid;
      if (stx < 0 || stx >= MAZE_SIZE || sty < 0 || sty >= MAZE_SIZE)
        return false;
      if (maze[stx][sty] == 1)
        return true;
    }
  }

  /**
   * 壁を延ばす（一定の確率で曲がり、四方がふさがれたら終了）
   */
  void createMazeBranch() {
    for (;;) {
      if (maze[stx + DMX[std] * mazeGrid][sty + DMY[std] * mazeGrid]
        == 0) {
        for (int i = 0; i < mazeGrid; i++) {
          stx += DMX[std];
          sty += DMY[std];
          maze[stx][sty] = 1;
        }
        if (mazePtn == 2) {
          if ((turnCnt % 6) == 0) {
            std++;
            std &= 3;
            turnCnt++;
          }
        } else {
          if (random(1) < 0.4f) {
            std += (int) random(2) * 2 - 1;
            std &= 3;
          }
        }
        pointNum--;
        if (pointNum <= 0)
          return;
        continue;
      } else {
        if (mazePtn == 2) {
          std++;
          std &= 3;
          turnCnt++;
        } else {
          std += (int) random(2) * 2 - 1;
          std &= 3;
        }
        if (maze[stx + DMX[std] * mazeGrid][sty + DMY[std] * mazeGrid]
          == 0)
          continue;
        std += 2;
        std &= 3;
        if (maze[stx + DMX[std] * mazeGrid][sty + DMY[std] * mazeGrid]
          == 1)
          return;
      }
    }
  }

  /**
   * 出口作成用に迷路を正方形に埋める
   * @param p 左上の座標
   * @param w 大きさ
   * @param v 埋める値
   */
  void fillMaze(int p, int w, int v) {
    for (int y = p; y < p + w; y++)
      for (int x = p; x < p + w; x++)
        maze[x][y] = v;
  }

  /**
   * 1フレームごとの処理
   */
  void loop() {
    if (state == IN_GAME)
      loopGame();
    else
      loopTitle();
  }

  /**
   * マウスリリース時にゲームスタートするためのフラグ
   */
  boolean startPressed = false;

  /**
   * タイトル時の1フレーム処理
   */
  void loopTitle() {
    background(255);
    cx += cmx;
    cy += cmy;
    wx = (int) (cx / mazeWallSize);
    wy = (int) (cy / mazeWallSize);
    if (cx < 0 || cx > MAZE_SIZE * mazeWallSize)
      cmx *= -1;
    if (cy < 0 || cy > MAZE_SIZE * mazeWallSize)
      cmy *= -1;
    drawMaze();
    boolean onStart;
    if (mouseX > width / 2 - 50
      && mouseX < width / 2 + 50
      && mouseY > height - 100
      && mouseY < height - 75)
      onStart = true;
    else
      onStart = false;
    push();
    translate(0, 0, 30);
    textSize(42);
    textMode(ALIGN_CENTER);
    fill(0, 0, 0);
    text("RallX", width / 2, height / 3);
    stroke(250, 100, 50);
    if (onStart)
      fill(250, 180, 100);
    else
      fill(200, 150, 50);
    strokeWeight(2);
    rect(width / 2 - 50, height - 100, 100, 25);
    strokeWeight(1);
    fill(0, 0, 0);
    textSize(25);
    text("START", width / 2, height - 80);
    pop();
    drawStatus();
    if (onStart && mousePressed)
      startPressed = true;
    if (!mousePressed && startPressed) {
      startPressed = false;
      if (onStart)
        startGame();
    }
  }

  /**
   * ゲーム中の1フレーム処理
   */
  void loopGame() {
    background(255);
    float pcx = cx, pcy = cy;
    cx += cmx;
    cy += cmy;
    cmx += (sin(cd) * csp - cmx) * 0.04f;
    cmy += (cos(cd) * csp - cmy) * 0.04f;
    int mox = mouseX - width / 2, moy = mouseY - height / 2;
    float mouseDst = sqrt(mox * mox + moy * moy);
    float brk = 0.85f + (mouseDst / (width / 2)) * 0.15f;
    if (brk > 1)
      brk = 1;
    cmx *= brk;
    cmy *= brk;
    cmd = atan2(cmx, cmy);
    cmsp = sqrt(cmx * cmx + cmy * cmy);
    score += cmsp * 0.05f;
    float md = adjustDeg(atan2(mox, moy) - cd);
    cd += md * 0.2f;
    cd = adjustDeg(cd);
    wx = (int) (cx / mazeWallSize);
    wy = (int) (cy / mazeWallSize);
    int pwx = (int) (pcx / mazeWallSize);
    int pwy = (int) (pcy / mazeWallSize);
    if (maze[wx][wy] == 1) {
      if (maze[pwx][wy] == 0) {
        cx = pcx;
        cmx *= -0.8f;
      } else if (maze[wx][pwy] == 0) {
        cy = pcy;
        cmy *= -0.8f;
      } else {
        cx = pcx;
        cmx *= -0.8f;
        cy = pcy;
        cmy *= -0.8f;
      }
    } else if (maze[wx][wy] == 2 && ccnt == 0 && flagNum <= 0) {
      ccnt = 1;
      stop(clearSe);
      play(clearSe);
    } else if (maze[wx][wy] == 3) {
      maze[wx][wy] = 0;
      score += 500;
      flagNum--;
      stop(flagSe);
      play(flagSe);
      if (flagNum <= 0) {
        msg = "Go to the exit.";
        mcnt = 60;
      }
    } else if (maze[wx][wy] >= 10) {
      int ri = maze[wx][wy] - 10;
      if (abs(rock[ri].x - cx) + abs(rock[ri].y - cy) < 20)
        miss();
    }
    float od = abs(adjustDeg(cd - cmd));
    if (od > 0.5f && cmsp > 6)
      addParticle(
        width / 2,
        height / 2,
        cmd + PI + random(-0.3f, 0.3f),
        cmsp);
    if (mousePressed) {
      csp += (5 - csp) * 0.3f;
      if (rcnt < 8)
        rcnt++;
    } else {
      csp += (20 - csp) * 0.3f;
      if (rcnt > 0)
        rcnt--;
    }
    if (ccnt > 0) {
      ccnt++;
      rcnt = 0;
      cmx *= 0.8;
      cmy *= 0.8;
      csp *= 0.6;
      if (time > 0) {
        time -= 30;
        score += 100;
        if (time > 30) {
          time -= 30;
          score += 100;
        }
      }
      if (ccnt > 30) {
        initStage();
        return;
      }
    } else if (ccnt < 0) {
      ccnt++;
    }
    if (dcnt > 0) {
      dcnt--;
      rcnt = 0;
      cmx *= 0.8;
      cmy *= 0.8;
      csp *= 0.6;
      if (dcnt > 30) {
        float v = 1 - (float) (250 - dcnt) / 60;
        if (v < 0)
          v = 0;
        volume(bgm, v);
        csp = 0;
        push();
        translate(0, 0, 30);
        textSize(32);
        textMode(ALIGN_CENTER);
        fill(0, 0, 0);
        text("Game Over", width / 2, height / 3);
        pop();
        if (dcnt < 100 || (dcnt < 230 && mousePressed)) {
          startTitle();
          return;
        }
      }
      if (dcnt == 1)
        time = STAGE_TIME;
    }
    if (dcnt == 0 && ccnt == 0) {
      time--;
      if (time <= 0)
        miss();
    }
    if (rcnt < 8) {
      push();
      if (ccnt > 0) {
        translate(0, 0, ccnt * 5);
        ca = 255 - ccnt * 12;
        if (ca < 0)
          ca = 0;
      } else {
        translate(0, 0, -rcnt * 30);
        ca = 255 - rcnt * 31;
        if (ccnt < 0)
          ca = 255 + ccnt * 31;
      }
      if (dcnt <= 0)
        drawCar(width / 2, height / 2, cd, cmd);
      drawMaze();
      noStroke();
      for (int i = 0; i < particle.length; i++)
        if (particle[i].cnt >= 0)
          particle[i].loop();
      pop();
    }
    if (rcnt > 0)
      drawMazeOnRadar();
    drawStatus();
  }

  /**
   * 自車が岩に突っ込んだ／時間切れ
   */
  void miss() {
    stop(crashSe);
    play(crashSe);
    dcnt = 30;
    for (int i = 0; i < 24; i++)
      addParticle(width / 2, height / 2, random(PI * 2), random(20));
    maze[wx][wy] = 0;
    left--;
    if (left < 0)
      dcnt = 250;
  }

  /**
   * 方向を -PI〜PI に収めることで曲がる方向の計算を楽に
   * @param d 補正前の角度
   * @return 補正後の角度
   */
  float adjustDeg(float d) {
    if (d > PI)
      return d - PI * 2;
    else if (d < -PI)
      return d + PI * 2;
    else
      return d;
  }

  /**
   * 車を書く
   * @param x x座標
   * @param y y座標（残機表示兼用のため座標が指定できる）
   * @param d1 前輪の方向（マウスの方向を向く）
   * @param d2 後輪の方向（移動方向を向く後輪）
   */
  void drawCar(int x, int y, float d1, float d2) {
    fill(100, 150, 250, ca);
    stroke(150, 200, 255, ca);
    push();
    translate(x, y);
    rotateZ(-d1);
    translate(0, 6);
    rect(-3, -6, 6, 12);
    pop();
    push();
    translate(x, y);
    rotateZ(-d2);
    translate(-6, -6);
    rect(-3, -6, 6, 12);
    translate(12, 0);
    rect(-3, -6, 6, 12);
    pop();
  }

  /**
   * スクロール画面上の迷路表示
   */
  void drawMaze() {
    float wsx, wsy;
    float swsx = -cx + (wx - wallSightRange) * mazeWallSize + width / 2;
    float swsy = -cy + (wy - wallSightRange) * mazeWallSize + height / 2;
    wsy = swsy;
    beginShape(QUADS);
    for (int y = wy - wallSightRange;
      y <= wy + wallSightRange;
      y++, wsy += mazeWallSize) {
      wsx = swsx;
      for (int x = wx - wallSightRange;
        x <= wx + wallSightRange;
        x++, wsx += mazeWallSize) {
        if (x >= 0 && x < MAZE_SIZE && y >= 0 && y < MAZE_SIZE) {
          if (maze[x][y] == 1)
            drawWall(wsx, wsy);
          else if (maze[x][y] == 2)
            drawGoal(wsx, wsy);
          else if (maze[x][y] == 3)
            drawFlag(wsx, wsy);
          else if (maze[x][y] >= 10) {
            int ri = maze[x][y] - 10;
            drawRock(wsx, wsy, rock[ri].ox, rock[ri].oy);
          }
        }
      }
    }
    endShape();
  }

  /**
   * 壁のz軸方向高さ
   */
  float WALL_height = 20;

  /**
   * 壁を書く
   * @param sx スクロール画面上のx座標
   * @param sy スクロール画面上のy座標
   */
  void drawWall(float sx, float sy) {
    fill(200, 250, 50, ca);
    stroke(100, 150, 100, ca);
    vertex(sx, sy, WALL_height);
    vertex(sx + mazeWallSize, sy, WALL_height);
    vertex(sx + mazeWallSize, sy + mazeWallSize, WALL_height);
    vertex(sx, sy + mazeWallSize, WALL_height);
    fill(220, 250, 150, ca);
    stroke(150, 200, 100, ca);
    vertex(sx, sy, WALL_height);
    vertex(sx + mazeWallSize, sy, WALL_height);
    vertex(sx + mazeWallSize, sy, 0);
    vertex(sx, sy, 0);
    vertex(sx + mazeWallSize, sy, WALL_height);
    vertex(sx + mazeWallSize, sy + mazeWallSize, WALL_height);
    vertex(sx + mazeWallSize, sy + mazeWallSize, 0);
    vertex(sx + mazeWallSize, sy, 0);
    vertex(sx + mazeWallSize, sy + mazeWallSize, WALL_height);
    vertex(sx, sy + mazeWallSize, WALL_height);
    vertex(sx, sy + mazeWallSize, 0);
    vertex(sx + mazeWallSize, sy + mazeWallSize, 0);
    vertex(sx, sy + mazeWallSize, WALL_height);
    vertex(sx, sy, WALL_height);
    vertex(sx, sy, 0);
    vertex(sx, sy + mazeWallSize, 0);
  }

  /**
   * 旗を回収し終わっていたらゴールを書く
   * @param sx スクロール画面上のx座標
   * @param sy スクロール画面上のy座標
   */
  void drawGoal(float sx, float sy) {
    if (flagNum > 0)
      return;
    fill(250, 200, 150, ca);
    stroke(250, 150, 200, ca);
    vertex(sx, sy, 0);
    vertex(sx + mazeWallSize, sy, 0);
    vertex(sx + mazeWallSize, sy + mazeWallSize, 0);
    vertex(sx, sy + mazeWallSize, 0);
  }

  /**
   * 岩を書く
   * @param x スクロール画面上のブロックのx座標
   * @param y スクロール画面上のブロックのx座標
   * @param ox ブロック座標からの補正xオフセット
   * @param oy ブロック座標からの補正yオフセット
   */
  void drawRock(float x, float y, float ox, float oy) {
    float sx = x + ox, sy = y + oy;
    sy -= 3;
    stroke(250, 50, 100, ca);
    fill(200, 100, 50, ca);
    vertex(sx - 8, sy - 8, 0.2f);
    vertex(sx + 8, sy - 8, 0.2f);
    vertex(sx + 8, sy + 8, 0.2f);
    vertex(sx - 8, sy + 8, 0.2f);
    fill(240, 200, 100, ca);
    sx += 5;
    sy += 8;
    vertex(sx - 8, sy - 8, 0.1f);
    vertex(sx + 8, sy - 8, 0.1f);
    vertex(sx + 8, sy + 8, 0.1f);
    vertex(sx - 8, sy + 8, 0.1f);
    fill(200, 220, 120, ca);
    sx -= 9;
    sy -= 4;
    vertex(sx - 8, sy - 8, 0);
    vertex(sx + 8, sy - 8, 0);
    vertex(sx + 8, sy + 8, 0);
    vertex(sx - 8, sy + 8, 0);
  }

  /**
   * 旗を書く
   * @param x スクロール画面上のx座標
   * @param y スクロール画面上のy座標
   */
  void drawFlag(float x, float y) {
    float sx = x + mazeWallSize / 3, sy = y + mazeWallSize / 3;
    fill(250, 250, 100, ca);
    stroke(250, 100, 50, ca);
    vertex(sx, sy, WALL_height);
    vertex(sx + 3, sy, WALL_height);
    vertex(sx + 3, sy + mazeWallSize / 3 * 2, 0);
    vertex(sx, sy + mazeWallSize / 3 * 2, 0);
    vertex(sx + 3, sy, WALL_height);
    vertex(sx + 13, sy, WALL_height);
    vertex(sx + 13, sy + 10, WALL_height / 3 * 2);
    vertex(sx + 3, sy + 10, WALL_height / 3 * 2);
  }

  /**
   * レーダー画面上の迷路と旗と自車を表示
   */
  void drawMazeOnRadar() {
    int a = rcnt * 32 - 1;
    push();
    translate(0, 0, -WALL_height * 2 + (8 - rcnt) * 20);
    noStroke();
    fill(255, 220, 180, a);
    for (int y = 0; y < MAZE_SIZE; y++)
      for (int x = 0; x < MAZE_SIZE; x++)
        if (maze[x][y] == 1)
          rect(
            x * mazeRectSize,
            y * mazeRectSize,
            mazeRectSize,
            mazeRectSize);
        else if (maze[x][y] == 3) {
          fill(200, 200, 50, a);
          rect(
            x * mazeRectSize,
            y * mazeRectSize,
            mazeRectSize,
            mazeRectSize);
          fill(255, 220, 180, a);
        }
    fill(100, 200, 255, a);
    rect(wx * mazeRectSize, wy * mazeRectSize, mazeRectSize, mazeRectSize);
    pop();
  }

  /**
   * スコアと残機と残りタイムとメッセージを表示
   */
  void drawStatus() {
    push();
    translate(0, 0, 30);
    textSize(26);
    textMode(ALIGN_RIGHT);
    fill(0, 0, 0);
    text((int) score, width - 18, 36);
    if (time > -999) {
      textMode(ALIGN_CENTER);
      textSize(33);
      text((time + 29) / 30, width / 2, height - 20);
    }
    for (int i = 0; i < left; i++)
      drawCar(i * 20 + 30, 30, PI, PI);
    if (mcnt > 0) {
      mcnt--;
      textMode(ALIGN_CENTER);
      textSize(24);
      fill(0, 0, 0);
      text(msg, width / 2, height / 3);
    }
    pop();
  }

  /**
   * スモーク状のパーティクル
   */
  class Particle {
    /**
     * 表示サイズ
     */
    float SIZE = 20;
    /**
     * 位置
     */
    float x, y;
    /**
     * 広がる方向および速度
     */
    float deg, speed;
    /**
     * アルファ値
     */
    int alpha;
    /**
     * 消えるまでのカウンタ
     */
    int cnt;

    /**
     * カウンタを-1に設定して非表示に
     */
    Particle() {
      cnt = -1;
    }

    /**
     * cntを設定して有効にする
     * @param x 初期x座標
     * @param y 初期y座標
     * @param d 方向
     * @param s スピード
     */
    void set(float x, float y, float d, float s) {
      this.x = x;
      this.y = y;
      deg = d;
      speed = s;
      alpha = 200 + (int) random(50);
      cnt = 15 + (int) random(15);
    }

    /**
     * 1フレーム毎の処理
     */
    void loop() {
      x += sin(deg) * speed;
      y += cos(deg) * speed;
      speed *= 0.95f;
      alpha *= 0.9f;
      cnt--;
      fill(200, 190, 120, alpha);
      ellipse(x, y, SIZE, SIZE);
    }
  }

  /**
   * パーティクルプールから次のインスタンスを指し示すためのインデックス
   */
  int particleIdx = 0;

  /**
   * パーティクル追加
   * @param x 初期x座標
   * @param y 初期y座標
   * @param d 方向
   * @param s スピード
   */
  void addParticle(float x, float y, float d, float s) {
    particleIdx--;
    if (particleIdx < 0)
      particleIdx += particle.length;
    particle[particleIdx].set(x, y, d, s);
  }

  /**
   * 岩（当たると痛い）
   */
  class Rock {
    /**
     * 迷路ブロック内のオフセット
     */
    float ox, oy;
    /**
     * どの迷路ブロックに配置されているか
     */
    float x, y;
  }
}