import java.lang.*;
import java.applet.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;

import Obj;

public class St
    extends Applet
    implements Runnable, KeyListener, MouseListener {

    Thread cycleExec = null;                // thread
    private int sleepTime = 16;             // threadスリープ時間

    // 仮想画面関連変数
    private int bgWidth  = 480;             // BG画面幅
    private int bgHeight = 320;             // BG画面高さ
    private Image bgBuff;                   // BGバッファ
    private Graphics bg;                    // BGバッファGraphics

    // キー入力管理変数
    private boolean KeyPress[];             // キー入力判定配列
    private final int LEFT  = 0;            // "←"キー識別
    private final int RIGHT = 1;            // "→"キー識別
    private final int UP    = 2;            // "↑"キー識別
    private final int DOWN  = 3;            // "↓"キー識別
    private final int SPACE = 4;            // " "キー識別
    private final int KEYS  = 5;            // 識別キー個数

    private boolean spKeyRel = true;        // " "キーリピートフラグ

    private boolean init;                   // 初期化判定フラグ

    private Obj own;                        // 自機オブジェクト

    private Obj zapper[];                   // 自機弾オブジェクト
    static final int zapNum = 8;            // 自機弾個数
    static final int zapRange = 96;         // 自機弾寿命
    private int zapCnt = 0;                 // 自機弾カウンタ

    private Obj lMeteo[];                   // 隕石(大)オブジェクト
    static final int lMetNum = 6;           // 隕石(大)個数
    private int lMetCnt = 0;                // 隕石(大)カウンタ

    private Obj mMeteo[];                   // 隕石(中)オブジェクト
    static final int mMetNum = 18;          // 隕石(中)個数
    private int mMetCnt = 0;                // 隕石(中)カウンタ

    private Obj sMeteo[];                   // 隕石(小)オブジェクト
    static final int sMetNum = 54;          // 隕石(小)個数
    private int sMetCnt = 0;                // 隕石(小)カウンタ

    private Obj particle[];                 // 破片オブジェクト
    static final int ptcNum =  96;          // 破片個数
    private int ptcCnt = 0;                 // 破片カウンタ
    static final int ptcLife = 64;          // 破片寿命

    private Color ownCol = new Color(0x00ff00); // 自機色
    private Color zapCol = new Color(0x00ff00); // 自機弾色
    private Color metCol = new Color(0x00cf00); // 隕石色
    private Color grdCol = new Color(0x006f00); // グリッド色
    private Color toneCol[];                    // 明->暗色配列

    static final int phTitle = 0;           // タイトル状態
    static final int phPlay  = 1;           // プレイ中状態
    static final int phGover = 2;           // GameOver状態

    int phase = phTitle;                    // 状態管理変数

    private int score;                      // Score
    private int stage;                      // Stage番号

    // Stage対応隕石個数,分裂数
    int mSts[][] = {{4, 2},
                    {5, 2},
                    {6, 2},
                    {4, 3},
                    {5, 3},
                    {6, 3}};

    static final int stageNum = 6;          // Stage数
    private int mNum;                       // 隕石個数
    private int mDiv;                       // 隕石分裂数

    static final int lMetScore = 40;        // 隕石(大)得点
    static final int mMetScore = 20;        // 隕石(中)得点
    static final int sMetScore = 10;        // 隕石(小)得点

    // 自機形状
    double ownShape[][]  = {{  7.0,   0.0},
                            { -5.0,   4.0},
                            { -5.0,  -4.0},
                            {  7.0,   0.0}};

    // 自機弾形状
    double zapShape[][]  = {{ -2.0,   1.5},
                            {  2.0,   0.0},
                            { -2.0,  -1.5},
                            { -2.0,   1.5}
                            };

    // 隕石(大)形状
    double lMetShape[][] = {{ 15.0,  -5.0},
                            {  5.0,  20.0},
                            { -5.0,  10.0},
                            {-15.0,  15.0},
                            {-20.0, -10.0},
                            {  5.0, -20.0},
                            { 15.0,  -5.0}};

    // 隕石(中)形状
    double mMetShape[][] = {{  8.0,  -3.0},
                            {  3.0,  10.0},
                            { -3.0,   5.0},
                            { -8.0,   8.0},
                            {-12.0,  -5.0},
                            {  3.0, -10.0},
                            {  8.0,  -3.0}};

    // 隕石(小)形状
    double sMetShape[][] = {{  4.0,  -2.0},
                            {  2.0,   5.0},
                            { -1.0,   2.0},
                            { -4.0,   4.0},
                            { -5.0,  -3.0},
                            {  2.0,  -5.0},
                            {  4.0,  -2.0}};

    // 破片形状
    double ptcShape[][]  = {{  0.0,   3.0},
                            {  2.0,  -1.0},
                            { -2.0,  -1.0},
                            {  0.0,   3.0}};

    // 12pointフォント
    private Font font12 = new Font("Helvetica", Font.PLAIN, 12);

    // 14pointフォント
    private Font font14 = new Font("Helvetica", Font.PLAIN, 14);

    // タイトル表示時用カウンタ
    private int titCnt = 0;
    private int titCntInc = 1;

    // コンストラクタ
    public St() {
    }

    public void init() {

        init = false;

        // オフスクリーン作成
        try {
            bgBuff = createImage(bgWidth, bgHeight);
        }
        catch (Exception e) {}

        // BG画面作成
        bg = bgBuff.getGraphics();
        bg.setFont(font12);

        // キー入力管理変数初期化
        KeyPress=new boolean[KEYS];
        for(int i=0; i<KEYS; i++) {
            KeyPress[i]=false;
        }

        // イベントリスナ登録
        addMouseListener(this);
        addKeyListener(this);

        // 自機生成
        own = new Obj(240.0, 160.0, 0.0, 0.0, 5.0, ownShape);
        own.setScrSize((double)bgWidth, (double)bgHeight);
        own.calcPos();

        // 自機弾生成
        zapper = new Obj[zapNum];
        for(int i=0; i<zapNum; i++) {
            zapper[i] = new Obj(2, zapShape);
        }

        // 破片生成
        particle = new Obj[ptcNum];
        for(int i=0; i<ptcNum; i++) {
            particle[i] = new Obj(1, ptcShape);
        }

        // 隕石(大)生成
        lMeteo = new Obj[lMetNum];
        for(int i=0; i<lMetNum; i++) {
            lMeteo[i] = new Obj(19, lMetShape);
        }

        // 隕石(中)生成
        mMeteo = new Obj[mMetNum];
        for(int i=0; i<mMetNum; i++) {
            mMeteo[i] = new Obj(12, mMetShape);
        }

        // 隕石(小)生成
        sMeteo = new Obj[sMetNum];
        for(int i=0; i<sMetNum; i++) {
            sMeteo[i] = new Obj(6, sMetShape);
        }

        // 明->暗色配列作成
        toneCol = new Color[ptcLife];
        for(int i=0; i<ptcLife; i++) {
            toneCol[i] = new Color(0, i*4, 0);
        }

        // 状態初期化
        initStatus();

        // 隕石(大)作成
        for(int i=0; i<lMetNum; i++) {
            lMetMake(Math.random()*479.0, Math.random()*319.0,
                     Math.random()*2.0-1.0, Math.random()*2.0-1.0, 1);
        }

        requestFocus(); // これがないとAppletviewerでちゃんと動かない。

        // 初期化完了
        init = true;
    }

    public void destroy() {
        this.removeMouseListener(this);
        this.removeKeyListener(this);
    }

    //==================================================================
    // 状態初期化処理
    //==================================================================
    void initStatus() {

        // 全般状況初期化
        stage = 0;
        score = 0;

        // 自機情報初期化
        own.posX = 240.0;
        own.posY = 160.0;
        own.vX = 0.0;
        own.vY = 0.0;
        own.vecTh = 270.0;

        // 自機弾初期化
        zapCnt = 0;
        for(int i=0; i<zapNum; i++) {
            zapper[i].life = 0;
        }

        // 隕石(大)初期化
        lMetCnt = 0;
        for(int i=0; i<lMetNum; i++) {
            lMeteo[i].life = 0;
        }

        // 隕石(中)初期化
        mMetCnt = 0;
        for(int i=0; i<mMetNum; i++) {
            mMeteo[i].life = 0;
        }

        // 隕石(小)初期化
        sMetCnt = 0;
        for(int i=0; i<sMetNum; i++) {
            sMeteo[i].life = 0;
        }
    }

    // thread開始処理
    public void start() {
        while(!init) {};

        if (cycleExec == null) {
            cycleExec = new Thread(this);
            cycleExec.start();
        }
    }

    // thread停止処理
    public void stop() {
        if (cycleExec != null) {
            cycleExec.stop();
            cycleExec = null;
        }
    }

    // thread実行処理
    public void run() {
        // 周期実行
        while(true) {

            switch(phase) {

                // 起動時処理
                case phTitle:
                    titDraw();
                    break;

                // Play中処理
                case phPlay:

                    // 状態判定
                    stsChk();

                    // 各当たり判定
                    objColl();

                    // 各オブジェクト移動処理
                    objMove();

                    // 描画処理
                    objDraw();
                    ownDraw();

                    break;

                // GameOver時処理
                case phGover:
                    objMove();
                    objDraw();
                    govDraw();
                    break;

                default:
                    break;
            }

            repaint();

            // スレッドをsleep
            try { cycleExec.sleep(sleepTime); }
            catch (InterruptedException e) { stop(); }
        }
    }

    public void paint(Graphics g) {
        g.drawImage(bgBuff, 0, 0, this);
    }

    public void update(Graphics g) {
        paint(g);
    }

    //==================================================================
    // 状態判定
    //==================================================================
    void stsChk() {
        if(lMetCnt == 0 && mMetCnt == 0 && sMetCnt == 0) {

            // Stage対応パラメータ設定
            mNum = mSts[stage][0];
            mDiv = mSts[stage][1];

            // 自機位置初期化
            own.posX = 240.0;
            own.posY = 160.0;

            // 自機弾初期化
            for(int i=0; i<zapNum; i++) {
                zapper[i].life = 0;
            }
            zapCnt = 0;

            // 隕石(大)作成
            for(int i=0; i<mNum; i++) {
                lMetMake(Math.random()*479.0, Math.random()*9.0,
                         Math.random()*2.0-1.0, Math.random()*2.0-1.0, 1);
            }

            // Stage数管理
            stage++;
            if(stage >= stageNum) {
                stage = 0;
            }
        }
    }

    //==================================================================
    // 各オブジェクト移動処理
    //==================================================================
    void objMove() {
        ownMove();
        zapMove();
        metMove();
        ptcMove();
    }

    // 自機移動処理
    void ownMove() {
        if(KeyPress[UP]) {
            own.thrust(own.vecTh, 0.1, 3.0);
        }
//      if(KeyPress[DOWN]) {
//      }
        if(KeyPress[LEFT]) {
            own.subVecTh(5.0);
        }
        if(KeyPress[RIGHT]) {
            own.addVecTh(5.0);
        }

        if(KeyPress[SPACE]) {

            // 押しっぱなしは駄目
            KeyPress[SPACE] = false;

            // 発射弾数チェック
            if(zapCnt < zapNum) {

                // 空きオブジェクト検索
                for(int i=0; i<zapNum; i++) {
                    if(zapper[i].life == 0) {
                        zapper[i].life = zapRange;
                        zapper[i].posX = own.posX;
                        zapper[i].posY = own.posY;
                        zapper[i].vecTh = own.vecTh;
                        zapper[i].vX = own.vX;
                        zapper[i].vY = own.vY;
                        zapper[i].thrust(own.vecTh, 1.5, 9.0);
                        zapCnt++;

                        break;
                    }
                }
            }
        }

        // 移動処理
        own.move();
        own.reduce(0.99);
        own.calcPos();
    }

    // 自機弾移動処理
    void zapMove() {
        for(int i=0; i<zapNum; i++) {

            // 生きているオブジェクトのみ移動
            if(zapper[i].life != 0) {
                zapper[i].move();
                zapper[i].calcPos();
                zapper[i].life--;

                // 寿命がつきたらカウンタを減らす
                if(zapper[i].life == 0) {
                    zapCnt--;
                }
            }
        }
    }

    // 破片移動処理
    void ptcMove() {
        for(int i=0; i<ptcNum; i++) {

            // 生きているオブジェクトのみ移動
            if(particle[i].life != 0) {
                particle[i].move();
                particle[i].calcPos();
                particle[i].life--;

                // 寿命がつきたらカウンタを減らす
                if(particle[i].life == 0) {
                    ptcCnt--;
                }
            }
        }
    }

    // 隕石移動処理
    void metMove() {
        for(int i=0; i<lMetNum; i++) {

            // 生きているオブジェクトのみ移動
            if(lMeteo[i].life != 0) {
                lMeteo[i].move();
                lMeteo[i].calcPos();
            }
        }
        for(int i=0; i<mMetNum; i++) {

            // 生きているオブジェクトのみ移動
            if(mMeteo[i].life != 0) {
                mMeteo[i].move();
                mMeteo[i].calcPos();
            }
        }
        for(int i=0; i<sMetNum; i++) {

            // 生きているオブジェクトのみ移動
            if(sMeteo[i].life != 0) {
                sMeteo[i].move();
                sMeteo[i].calcPos();
            }
        }
    }


    //==================================================================
    // 各オブジェクト作成処理
    //==================================================================
    // 破片作成
    void ptcMake(double posx, double posy, double vx, double vy, int num) {
        int mkCnt = 0;
        for(int i=0; i<ptcNum; i++) {

            // 作成数チェック
            if(ptcCnt >= ptcNum) {
                break;
            }

            // 空きオブジェクト検索
            if(particle[i].life == 0) {
                particle[i].life = ptcLife-1;
                particle[i].rotTh = (Math.random() - 0.5)*10.0;
                particle[i].vecTh = Math.random() * 359.0;
                particle[i].posX = posx;
                particle[i].posY = posy;
                particle[i].vX = vx;
                particle[i].vY = vy;
                particle[i].thrust(Math.random() * 359.0, Math.random(), 10.0);
                ptcCnt++;

                // 指定数作成したら終了
                mkCnt++;
                if(mkCnt >= num) {
                    break;
                }
            }
        }
    }

    // 隕石(大)作成
    void lMetMake(double posx, double posy, double vx, double vy, int num) {
        int mkCnt = 0;
        for(int i=0; i<lMetNum; i++) {

            // 作成数チェック
            if(lMetCnt >= lMetNum) {
                break;
            }

            // 空きオブジェクト検索
            if(lMeteo[i].life == 0) {
                lMeteo[i].life = -1;
                lMeteo[i].rotTh = (Math.random() - 0.5)*10.0;
                lMeteo[i].vecTh = Math.random() * 359.0;
                lMeteo[i].posX = posx;
                lMeteo[i].posY = posy;
                lMeteo[i].vX = vx;
                lMeteo[i].vY = vy;
                lMeteo[i].thrust(Math.random() * 359.0, Math.random()+0.5, 2.0);
                lMetCnt++;

                // 指定数作成したら終了
                mkCnt++;
                if(mkCnt >= num) {
                    break;
                }
            }
        }
    }

    // 隕石(中)作成
    void mMetMake(double posx, double posy, double vx, double vy, int num) {
        int mkCnt = 0;
        for(int i=0; i<mMetNum; i++) {

            // 作成数チェック
            if(mMetCnt >= mMetNum) {
                break;
            }

            // 空きオブジェクト検索
            if(mMeteo[i].life == 0) {
                mMeteo[i].life = -1;
                mMeteo[i].rotTh = (Math.random() - 0.5)*10.0;
                mMeteo[i].vecTh = Math.random() * 359.0;
                mMeteo[i].posX = posx;
                mMeteo[i].posY = posy;
                mMeteo[i].vX = vx;
                mMeteo[i].vY = vy;
                mMeteo[i].thrust(Math.random() * 359.0, Math.random(), 2.0);
                mMetCnt++;

                // 指定数作成したら終了
                mkCnt++;
                if(mkCnt >= num) {
                    break;
                }
            }
        }
    }

    // 隕石(小)作成
    void sMetMake(double posx, double posy, double vx, double vy, int num) {
        int mkCnt = 0;
        for(int i=0; i<sMetNum; i++) {

            // 作成数チェック
            if(sMetCnt >= sMetNum) {
                break;
            }

            // 空きオブジェクト検索
            if(sMeteo[i].life == 0) {
                sMeteo[i].life = -1;
                sMeteo[i].rotTh = (Math.random() - 0.5)*10.0;
                sMeteo[i].vecTh = Math.random() * 359.0;
                sMeteo[i].posX = posx;
                sMeteo[i].posY = posy;
                sMeteo[i].vX = vx;
                sMeteo[i].vY = vy;
                sMeteo[i].thrust(Math.random() * 359.0, Math.random(), 2.0);
                sMetCnt++;

                // 指定数作成したら終了
                mkCnt++;
                if(mkCnt >= num) {
                    break;
                }
            }
        }
    }


    //==================================================================
    // 各オブジェクト衝突判定
    //==================================================================
    void objColl() {
        zapColl();
        ownColl();
    }

    // 自機弾当たり判定
    void zapColl() {
        for(int i=0; i<zapNum; i++) {

            // 生きている自機弾についてのみ判定
            if(zapper[i].life != 0) {
                for(int j=0; j<lMetNum; j++) {

                    // 生きている隕石(大)についてのみ判定
                    if(lMeteo[j].life != 0) {
                        double dist = objDist2(zapper[i], lMeteo[j]);

                        if(dist < lMeteo[j].size2) {

                            // 隕石(大)消去処理
                            lMeteo[j].life = 0;
                            lMetCnt--;

                            // 自機弾消去処理
                            zapper[i].life = 0;
                            zapCnt--;

                            // 破片作成
                            ptcMake(lMeteo[j].posX, lMeteo[j].posY,
                                    lMeteo[j].vX, lMeteo[j].vY, 8);

                            // 隕石(中)作成
                            mMetMake(lMeteo[j].posX, lMeteo[j].posY,
                                     lMeteo[j].vX, lMeteo[j].vY, mDiv);

                            score += lMetScore;

                            break;
                        }
                    }
                }
            }

            // 生きている自機弾についてのみ判定
            if(zapper[i].life != 0) {
                for(int j=0; j<mMetNum; j++) {

                    // 生きている隕石(中)についてのみ判定
                    if(mMeteo[j].life != 0) {
                        double dist = objDist2(zapper[i], mMeteo[j]);

                        if(dist < mMeteo[j].size2) {

                            // 隕石(中)消去処理
                            mMeteo[j].life = 0;
                            mMetCnt--;

                            // 自機弾消去処理
                            zapper[i].life = 0;
                            zapCnt--;

                            // 破片作成
                            ptcMake(mMeteo[j].posX, mMeteo[j].posY,
                                    mMeteo[j].vX, mMeteo[j].vY, 8);

                            // 隕石(小)作成
                            sMetMake(mMeteo[j].posX, mMeteo[j].posY,
                                     mMeteo[j].vX, mMeteo[j].vY, mDiv);

                            score += mMetScore;

                            break;
                        }
                    }
                }
            }

            // 生きている自機弾についてのみ判定
            if(zapper[i].life != 0) {
                for(int j=0; j<sMetNum; j++) {

                    // 生きている隕石(小)についてのみ判定
                    if(sMeteo[j].life != 0) {
                        double dist = objDist2(zapper[i], sMeteo[j]);

                        if(dist < sMeteo[j].size2) {

                            // 隕石(小)消去処理
                            sMeteo[j].life = 0;
                            sMetCnt--;

                            // 自機弾消去処理
                            zapper[i].life = 0;
                            zapCnt--;

                            // 破片作成
                            ptcMake(sMeteo[j].posX, sMeteo[j].posY,
                                    sMeteo[j].vX, sMeteo[j].vY, 8);

                            score += sMetScore;

                            break;
                        }
                    }
                }
            }
        }
    }

    // 自機衝突判定
    void ownColl() {
        double dist2;

        for(int i=0; i<lMetNum; i++) {

            // 生きている隕石(大)についてのみ判定
            if(lMeteo[i].life != 0) {
                dist2 = objDist2(own, lMeteo[i]);

                if(dist2 < (lMeteo[i].size2 + own.size)) {
                    // GameOverとする
                    phase = phGover;

                    // 破片作成
                    ptcMake(own.posX, own.posY,
                            own.vX+lMeteo[i].vX,
                            own.vY+lMeteo[i].vY, 12);
                }
            }
        }
        for(int i=0; i<mMetNum; i++) {

            // 生きている隕石(中)についてのみ判定
            if(mMeteo[i].life != 0) {
                dist2 = objDist2(own, mMeteo[i]);

                if(dist2 < (mMeteo[i].size2 + own.size)) {
                    // GameOverとする
                    phase = phGover;

                    // 破片作成
                    ptcMake(own.posX, own.posY,
                            own.vX+mMeteo[i].vX,
                            own.vY+mMeteo[i].vY, 12);
                }
            }
        }
        for(int i=0; i<sMetNum; i++) {

            // 生きている隕石(小)についてのみ判定
            if(sMeteo[i].life != 0) {
                dist2 = objDist2(own, sMeteo[i]);

                if(dist2 < (sMeteo[i].size2 + own.size)) {
                    // GameOverとする
                    phase = phGover;

                    // 破片作成
                    ptcMake(own.posX, own.posY,
                            own.vX+sMeteo[i].vX,
                            own.vY+sMeteo[i].vY, 12);
                }
            }
        }
    }

    //==================================================================
    // ２つのオブジェクト間距離の２乗算出処理
    //==================================================================
    double objDist2(Obj o1, Obj o2) {
        return (o1.posX - o2.posX)*(o1.posX - o2.posX) +
               (o1.posY - o2.posY)*(o1.posY - o2.posY);
    }


    //==================================================================
    // 各オブジェクト描画処理
    //==================================================================
    void objDraw() {
        eraseMpd();
        ptcDraw();
        grdDraw();
        metDraw();
        stsDraw();
    }

    // 画面消去
    void eraseMpd() {
        bg.setColor(Color.black);
        bg.fillRect(0, 0, bgWidth, bgHeight);
    }

    // グリッド描画
    void grdDraw() {
        bg.setColor(grdCol);
        for(int x=0; x<bgWidth; x+=40) {
            bg.drawLine(x, 0, x, bgHeight);
        }
        bg.drawLine(bgWidth-1, 0, bgWidth-1, bgHeight);
        for(int y=0; y<bgHeight; y+=40) {
            bg.drawLine(0, y, bgWidth, y);
        }
        bg.drawLine(0, bgHeight-1, bgWidth, bgHeight-1);
    }

    // 自機関連描画
    void ownDraw() {

        // 自機描画
        bg.setColor(ownCol);
        bg.drawPolyline(own.shpX, own.shpY, own.shpX.length);

        // 自機弾描画
        bg.setColor(zapCol);
        for(int i=0; i<zapNum; i++) {

            // 生きている自機弾のみ描画
            if(zapper[i].life != 0) {
                bg.drawPolyline(zapper[i].shpX, zapper[i].shpY,
                                zapper[i].shpX.length);
            }
        }
    }

    // 隕石描画
    void metDraw() {
        bg.setColor(metCol);

        // 隕石(大)描画
        for(int i=0; i<lMetNum; i++) {

            // 生きている隕石(大)のみ描画
            if(lMeteo[i].life != 0) {
                bg.drawPolyline(lMeteo[i].shpX, lMeteo[i].shpY,
                                lMeteo[i].shpX.length);
            }
        }

        // 隕石(中)描画
        for(int i=0; i<mMetNum; i++) {

            // 生きている隕石(中)のみ描画
            if(mMeteo[i].life != 0) {
                bg.drawPolyline(mMeteo[i].shpX, mMeteo[i].shpY,
                                mMeteo[i].shpX.length);
            }
        }

        // 隕石(小)描画
        for(int i=0; i<sMetNum; i++) {

            // 生きている隕石(小)のみ描画
            if(sMeteo[i].life != 0) {
                bg.drawPolyline(sMeteo[i].shpX, sMeteo[i].shpY,
                                sMeteo[i].shpX.length);
            }
        }
    }

    // 破片描画
    void ptcDraw() {
        for(int i=0; i<ptcNum; i++) {

            // 生きている破片のみ描画
            if(particle[i].life != 0) {
                bg.setColor(toneCol[particle[i].life]);
                bg.drawPolyline(particle[i].shpX, particle[i].shpY,
                                particle[i].shpX.length);

            }
        }
    }

    // タイトル画面表示
    void titDraw() {
        eraseMpd();

        // 隕石描画
        metMove();
        metDraw();

        // 操作説明表示
        bg.setColor(Color.green);
        bg.setFont(font12);
        bg.drawString("=== Operating instruction ===", 160, 120);
        bg.drawString("[LEFT] / [RIGHT] key : Rotate", 164, 140);
        bg.drawString("[UP] key : Thrust", 164, 160);
        bg.drawString("[SPACE] key : Fire", 164, 180);

        // "Click to start."表示
        bg.setColor(toneCol[titCnt]);
        bg.setFont(font14);
        bg.drawString("Click to start.", 200, 220);

        titCnt += titCntInc;
        if(titCnt >= ptcLife) {
            titCnt = ptcLife-1;
            titCntInc = -titCntInc;
        }
        if(titCnt < 0) {
            titCnt = 0;
            titCntInc = -titCntInc;
        }
    }

    // プレイ中ステータス表示
    void stsDraw() {

        // Score表示
        bg.setColor(Color.green);
        String str = Integer.toString(score);
        str = "00000"+str;
        String str2 = str.substring(str.length() - 5);
        bg.drawString("Score : "+str2, 10, 13);
    }

    // GameOver時表示
    void govDraw() {
        bg.setColor(Color.green);

        // 何故か繰り返し描かないと表示されない処理系がある
        for(int i=0; i<16; i++) {
            bg.drawString("Game Over", 204, 150);
            bg.drawString("Hit [Down] key to replay.", 165, 181);
        }
    }


    //==================================================================
    // KeyListener Method
    //==================================================================
    public void keyPressed(KeyEvent e) {
        switch(e.getKeyCode()) {
            case KeyEvent.VK_UP:
            case KeyEvent.VK_NUMPAD8:
                KeyPress[UP]=true;
                KeyPress[DOWN]=false;
                break;
            case KeyEvent.VK_DOWN:
            case KeyEvent.VK_NUMPAD2:
                KeyPress[DOWN]=true;
                KeyPress[UP]=false;

                if(phase == phGover) {
                    initStatus();
                    phase = phPlay;
                }

                break;
            case KeyEvent.VK_LEFT:
            case KeyEvent.VK_NUMPAD4:
                KeyPress[LEFT]=true;
                KeyPress[RIGHT]=false;
                break;
            case KeyEvent.VK_RIGHT:
            case KeyEvent.VK_NUMPAD6:
                KeyPress[RIGHT]=true;
                KeyPress[LEFT]=false;
                break;
            case KeyEvent.VK_SPACE:
                if(spKeyRel) {
                    KeyPress[SPACE]=true;
                    spKeyRel = false;
                } else {
                    KeyPress[SPACE]=false;
                }

                break;
        }
    }

    public void keyReleased(KeyEvent e) {
        switch(e.getKeyCode()) {
            case KeyEvent.VK_UP:
                KeyPress[UP]=false;
                break;
            case KeyEvent.VK_DOWN:
                KeyPress[DOWN]=false;
                break;
            case KeyEvent.VK_LEFT:
                KeyPress[LEFT]=false;
                break;
            case KeyEvent.VK_RIGHT:
                KeyPress[RIGHT]=false;
                break;
            case KeyEvent.VK_SPACE:
                KeyPress[SPACE]=false;
                spKeyRel = true;
                break;
        }
    }

    public void keyTyped(KeyEvent e) {
    }

    //==================================================================
    // MouseListener Method
    //==================================================================
    public void mouseClicked(MouseEvent e) {
        // マウスクリック
        if(phase == phTitle) {
            for(int i=0; i<lMetNum; i++) {
                lMeteo[i].life = 0;
            }
            lMetCnt = 0;
            phase = phPlay;
        }
    }

    public void mouseReleased(MouseEvent e) {
        // マウスボタン離す
    }

    public void mouseEntered(MouseEvent e) {
        // マウスカーソル入る
    }

    public void mousePressed(MouseEvent e) {
        // マウスボタン押す
    }

    public void mouseExited(MouseEvent e) {
        // マウスカーソル出る
    }
}


import java.lang.*;

public class Obj {

    public double posX;         // 位置ｘ座標
    public double posY;         // 位置ｙ座標
    public double posZ;         // 位置ｚ座標

    public double vecTh;        // 方位ベクトル
    public double rotTh;        // 回転速度

    public double vel;          // 速度
    public double vX;           // 速度ｘ成分
    public double vY;           // 速度ｙ成分
    public double vZ;           // 速度ｚ成分

    public double size;         // 大きさ
    public double size2;        // 大きさの２乗

    public double shape[][];    // 表示形状
    public int shpX[];          // 表示形状ｘ座標点列
    public int shpY[];          // 表示形状ｙ座標点列

    public int life;            // 寿命

    static final double d2r = Math.PI / 180.0;  // Degree/Radian変換係数

    static double scrW;         // 表示画面幅
    static double scrH;         // 表示画面高さ

    // コンストラクタ(その１)
    public Obj(double x,        // 位置ｘ座標
               double y,        // 位置ｙ座標
               double rot,      // 自動回転角
               double vec,      // 姿勢角
               double sz,       // 物体サイズ
               double sh[][]    // 物体形状
               ) {
        posX = x;
        posY = y;
        posZ = 0.0;
        rotTh = rot;
        vecTh = vec;
        vel = 0.0;
        vX = 0.0;
        vY = 0.0;
        vZ = 0.0;

        size = sz;
        size2 = sz*sz;

        shape = sh;

        // 物体形状２次元配列をx/y点列に変換
        shpX = new int[sh.length];
        shpY = new int[sh.length];

        life = -1;
    }

    // コンストラクタ(その２)
    public Obj(double sz,       // 物体サイズ
               double sh[][]    // 物体形状
              ) {
        posX = 0.0;
        posY = 0.0;
        posZ = 0.0;
        rotTh = 0.0;
        vecTh = 0.0;
        vel = 0.0;
        vX = 0.0;
        vY = 0.0;
        vZ = 0.0;

        size = sz;
        size2 = sz*sz;

        shape = sh;

        // 物体形状２次元配列をx/y点列に変換
        shpX = new int[sh.length];
        shpY = new int[sh.length];

        life = 0;
    }

    // 画面サイズの設定
    public void setScrSize(double w,    // 表示画面幅
                           double h     // 表示画面高さ
                           ) {
        scrW = w;
        scrH = h;
    }

    // 姿勢算出
    public void calcPos() {
        double sn = Math.sin(vecTh * d2r);
        double cs = Math.cos(vecTh * d2r);

        for(int i=0; i<shape.length; i++) {
            shpX[i] = (int)(posX + shape[i][0]*cs - shape[i][1]*sn);
            shpY[i] = (int)(posY + shape[i][0]*sn + shape[i][1]*cs);
        }
    }

    // 姿勢角増加(右回り)
    public void addVecTh(double th  // 増加差分
                        ) {
        vecTh += th;
        if(vecTh >= 360.0) {
            vecTh -= 360.0;
        }
    }

    // 姿勢角減少(左回り)
    public void subVecTh(double th  // 減少差分
                        ) {

        vecTh -= th;
        if(vecTh < 0.0) {
            vecTh += 360.0;
        }
    }

    // 指定方位へ加速
    public void thrust(double th,   // 加速方位
                       double v,    // 加速量
                       double limV  // 制限速度
                      ) {

        double vel2;

        vX += v * Math.cos(th * d2r);
        vY += v * Math.sin(th * d2r);
        vel2 = vX*vX+vY*vY;

        // 制限速度を超えた場合、速度の正規化を行う。
        if(vel2 > limV*limV) {
            vX *= ((limV*limV) / vel2);
            vY *= ((limV*limV) / vel2);
        }

    }

    // 一定率加減速
    public void reduce(double rate  // 加減速率
                      ) {
        vX *= rate;
        vY *= rate;
    }

    // 移動処理
    public void move() {

        // 姿勢角計算
        vecTh += rotTh;
        if(vecTh >= 360.0) {
            vecTh -= 360.0;
        }
        if(vecTh < 0.0) {
            vecTh += 360.0;
        }

        // 位置計算
        posX += vX;
        posY += vY;

        if(posX >= scrW) {
            posX -= scrW;
        }
        if(posX < 0.0) {
            posX += scrW;
        }
        if(posY >= scrH) {
            posY -= scrH;
        }
        if(posY < 0.0) {
            posY += scrH;
        }
    }
}