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

public final class Ts extends Applet
    implements Runnable, KeyListener, MouseListener {

    //========================================================================
    // Thread関連情報
    //========================================================================
    // thread
    private volatile Thread cycThread = null;
    private static int sleepTime = 16;    // threadスリープ時間

    //========================================================================
    // システムプロパティ情報
    //========================================================================
    private static String sysJavaVersion;    // Javaバージョン
    private static String sysJavaVendor;     // Javaベンダー
    private static String sysJavaVendorUrl;  // JavaベンダーURL
    private static String sysJavaApiVersion; // JavaAPIバージョン
    private static String sysOsName;         // OS名称
    private static String sysOsArch;         // CPUアーキテクチャ
    private static String sysOsVersion;      // OSバージョン

    //========================================================================
    // 仮想画面関連情報
    //========================================================================
    private final int bgWidth  = 256;       // BG画面幅
    private final int bgHeight = 384;       // BG画面高さ
    private Image bgBuff;                   // BGバッファ
    private Graphics bg;                    // BGバッファGraphics
    private double scrnSzX;                 // 画面サイズｘ
    private double scrnSzY;                 // 画面サイズｙ

    //========================================================================
    // CPU速度計測用情報
    //========================================================================
    static final int monFrame = 100;        // CPU速度計測フレーム数
    static int monCntr = 0;                 // CPU速度計測用カウンタ
    static int monFlag = 0;                 // CPU速度計測用フラグ
    private static long nowTime = 0;
    private static long oldTime;

    //========================================================================
    // キー入力管理情報
    //========================================================================
    private boolean keyPress[];             // キー入力判定配列
    private final int KEYS  = 5;            // 識別キー個数
    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 int spKeyCntr = 0;              // " "キー連射用カウンタ
    private final int FIRE_INT = 2;         // 連射間隔

    //========================================================================
    // 状態遷移管理情報
    //========================================================================
    private boolean init;                   // 初期化判定フラグ
    static final int phInit     = 0;        // CPU速度計測状態
    static final int phTitle    = 1;        // タイトル状態
    static final int phPlay     = 2;        // プレイ中状態
    static final int phGameover = 3;        // GameOver状態
    private int phase = phInit;             // 状態管理変数
    private int filterCnt = 0;              // 画面マスク処理用カウンタ
    private int gameoverCnt = 0;            // GAMEOVER文字表示用カウンタ
    private boolean clearFlag = false;      // ゲームクリアフラグ

    //========================================================================
    // 背景関連情報
    //========================================================================
    private final Color bgCol = new Color(0x404080);      // 背景色
    private final Color grdCol = new Color(0x8080c0);     // グリッド色
    private int bgScr = 0;                                // 背景スクロール量
    private Color ownHpCol[];                             // 自機HP表示色
    private final int ownHpColG = 16;                     // 自機HP表示色階調

    //========================================================================
    // タイトル画面関連情報
    //========================================================================
    private final Color textOsCol = new Color(0xd0d0ff);  // システム情報色
    private final Color textMsgCol = new Color(0xffffff); // メッセージ色
    private final Color titleBgCol = new Color(0x8080c0); // タイトル背景色

    //========================================================================
    // ちらつき色
    //========================================================================
    private Color flickCol;
    private Color flCol[];
    private int flCnt = 0;
    private final int flNum = 4;

    //========================================================================
    // 自機関連情報
    //========================================================================
    private final int ownMaxTurnRate = 12;         // 最大旋回角
    private final int ownTurnRate = 4;             // 旋回率
    private int ownCrs = 0;                        // 針路(DEG)
    private final double ownIniPosX = 128.0;       // ｘ座標初期値
    private final double ownIniPosY = 300.0;       // ｙ座標初期値
    private final int ownHp = 127;                 // 自機HP
    private static int score = 0;

    //========================================================================
    // オブジェクト情報
    //========================================================================
    private Own own;
    private Zapper zapper[];
    private Spark spark[];
    private Blast blast[];
    private EnemA eA[];
    private EnemB eB[];
    private EnemC eC[];
    private EnemD eD[];
    private Bullet bullet[];

    //========================================================================
    // 場面展開情報
    //========================================================================
    private static int tick = 0;      // システムカウンタ
    private static int mapCntr = 0;   // マップカウンタ
    private static int mapWidth;      // マップ幅
    private static int mapHeight;     // マップ高さ
    private static int level = 0;     // 難易度
    private static int remain;        // 残り時間

    //========================================================================
    // コンストラクタ
    //========================================================================
    public Ts() {
        System.out.println("Ts()");
    }

    //========================================================================
    // 初期化処理
    //========================================================================
    public void init() {
        System.out.println("init()");
        //--------------------------------------------------------------------
        // 初期化完了フラグの設定
        //--------------------------------------------------------------------
        init = false;

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

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

        //--------------------------------------------------------------------
        // 画面サイズ設定
        //--------------------------------------------------------------------
        scrnSzX = bgWidth;
        scrnSzY = bgHeight;

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

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

        //--------------------------------------------------------------------
        // Map情報取得
        //--------------------------------------------------------------------
        mapWidth = Map.getMapSizeX();
        mapHeight = Map.getMapSizeY(0);

        //--------------------------------------------------------------------
        // オブジェクト生成処理
        //--------------------------------------------------------------------
        // 自機生成
        own = new Own(ownIniPosX, ownIniPosY);

        // 自機弾生成
        zapper = new Zapper[Zapper.getNum()];
        for(int i=0; i<Zapper.getNum(); i++) {
            zapper[i] = new Zapper();
        }

        // 火花生成
        spark = new Spark[Spark.getNum()];
        for(int i=0; i<Spark.getNum(); i++) {
            spark[i] = new Spark();
        }

        // 爆風生成
        blast = new Blast[Blast.getNum()];
        for(int i=0; i<Blast.getNum(); i++) {
            blast[i] = new Blast();
        }

        // 敵弾生成
        bullet = new Bullet[Bullet.getNum()];
        for(int i=0; i<Bullet.getNum(); i++) {
            bullet[i] = new Bullet();
        }

        // 敵A生成
        eA = new EnemA[EnemA.getNum()];
        for(int i=0; i<EnemA.getNum(); i++) {
            eA[i] = new EnemA();
        }

        // 敵B生成
        eB = new EnemB[EnemB.getNum()];
        for(int i=0; i<EnemB.getNum(); i++) {
            eB[i] = new EnemB();
        }

        // 敵C生成
        eC = new EnemC[EnemC.getNum()];
        for(int i=0; i<EnemC.getNum(); i++) {
            eC[i] = new EnemC();
        }

        // 敵C生成
        eD = new EnemD[EnemD.getNum()];
        for(int i=0; i<EnemD.getNum(); i++) {
            eD[i] = new EnemD();
        }

        //--------------------------------------------------------------------
        // 色生成処理
        //--------------------------------------------------------------------
        flCol = new Color[flNum];
        flCol[0] = new Color(0xd0a0a0);
        flCol[1] = new Color(0xffffff);
        flCol[2] = new Color(0xd0d0a0);
        flCol[3] = new Color(0xffffe0);

        ownHpCol = new Color[ownHpColG];
        for(int i=0; i<ownHpColG; i++) {
            ownHpCol[i] = new Color(0xff, i*16, 0x40+i*4);
        }

        //--------------------------------------------------------------------
        // システムプロパティの取得
        //--------------------------------------------------------------------
        sysJavaVersion = System.getProperty("java.version", "UNKNOWN.");
        sysJavaVendor = System.getProperty("java.vendor", "UNKNOWN.");
        sysJavaVendorUrl = System.getProperty("java.vendor.url", "UNKNOWN.");
        sysJavaApiVersion = System.getProperty("java.class.version", "UNKNOWN.");
        sysOsName = System.getProperty("os.name", "UNKNOWN.");
        sysOsArch = System.getProperty("os.arch", "UNKNOWN.");
        sysOsVersion = System.getProperty("os.version", "UNKNOWN.");

        System.out.println(sysJavaVersion);
        System.out.println(sysJavaVendor);
        System.out.println(sysJavaVendorUrl);
        System.out.println(sysJavaApiVersion);
        System.out.println(sysOsName);
        System.out.println(sysOsArch);
        System.out.println(sysOsVersion);

        tick = 0;

        //--------------------------------------------------------------------
        // ウィンドウフォーカスの取得
        //--------------------------------------------------------------------
        requestFocus();     // これがないとAppletviewerでちゃんと動かない。

        //--------------------------------------------------------------------
        // 初期化完了フラグの設定
        //--------------------------------------------------------------------
        init = true;
    }

    //========================================================================
    // 終了処理
    //========================================================================
    public void destroy() {
        System.out.println("destroy()");
        this.removeMouseListener(this);
        this.removeKeyListener(this);
    }

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

        //--------------------------------------------------------------------
        // オブジェクトの初期化
        //--------------------------------------------------------------------
        for(int i=0; i<zapper.length; i++) {
            zapper[i].kill();
        }
        for(int i=0; i<spark.length; i++) {
            spark[i].kill();
        }
        for(int i=0; i<blast.length; i++) {
            blast[i].kill();
        }
        for(int i=0; i<bullet.length; i++) {
            bullet[i].kill();
        }
        for(int i=0; i<eA.length; i++) {
            eA[i].kill();
        }
        for(int i=0; i<eB.length; i++) {
            eB[i].kill();
        }
        for(int i=0; i<eC.length; i++) {
            eC[i].kill();
        }
        for(int i=0; i<eD.length; i++) {
            eD[i].kill();
        }

        //--------------------------------------------------------------------
        // 自機位置初期化
        //--------------------------------------------------------------------
        own.setPos(ownIniPosX, ownIniPosY);

        //--------------------------------------------------------------------
        // マップカウンタ初期化
        //--------------------------------------------------------------------
        mapCntr = 0;
        level = 0;

        // CPU速度計測用カウンタ初期化
        monCntr = 0;
        monFlag = 0;

        //--------------------------------------------------------------------
        // 自機初期化
        //--------------------------------------------------------------------
        own.setHp(ownHp);

        //--------------------------------------------------------------------
        // その他初期化
        //--------------------------------------------------------------------
        score = 0;
        remain = mapHeight * 3;
        clearFlag = false;
    }

    //========================================================================
    // thread開始処理
    //========================================================================
    public void start() {
        System.out.println("start()");
        // 初期化完了までは開始しない

        while(!init) {};

        //--------------------------------------------------------------------
        // 状態初期化
        //--------------------------------------------------------------------
        initState();

        if(phase != phInit) {
            phase = phTitle;
        }

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

    //========================================================================
    // thread停止処理
    //========================================================================
    public void stop() {
        System.out.println("stop()");
        if (cycThread != null) {
            cycThread = null;
        }
    }

    //========================================================================
    // thread実行処理
    //========================================================================
    public void run() {
        Thread thisThread = Thread.currentThread();

        // 周期実行
        while(cycThread == thisThread) {

            cycle();

            switch(phase) {

                // タイトル表示処理
                case phInit:
                case phTitle:
                    title();
                    break;

                // プレイ中処理
                case phPlay:
                    play();
                    if(filterCnt < 16) {
                        maskScreen();
                        if((tick & 0x03) == 0) {
                            filterCnt++;
                        }
                    }
                    break;

                // GameOver時処理
                case phGameover:
                    gameoverCnt++;
                    gameover();
                    break;

                default:
                    break;
            }

            // Netscape(4.73)で実行すると、repaint直前の描画命令が
            // いくつか捨てられるようなので暫定対処。
            // ↓↓↓↓ダミー描画処理↓↓↓↓
            for(int i=0; i<20; i++) {
                bg.fillRect(-100, -100, 10, 10);
            }
            // ↑↑↑↑ダミー描画処理↑↑↑↑

            repaint();

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

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

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

    //========================================================================
    // 周期処理
    //========================================================================
    private void cycle() {
        int modTime;
        int workTime;

        flickCol = flCol[flCnt];
        flCnt++;
        if(flCnt >= flNum) {
            flCnt = 0;
        }

        if((tick & 0x0f) == 0) {
            if(own.getHp() < ownHp) {
                own.mdfHp(+1);
            }
        }

        if(phase == phInit) {
        if(monCntr == 0) {
            nowTime = System.currentTimeMillis();
        }

        if((monCntr >= monFrame) && monFlag == 0) {
            monFlag = 1;

            oldTime = nowTime;
            nowTime = System.currentTimeMillis();
            modTime = (int)((nowTime - oldTime)/monFrame);

            workTime = modTime - sleepTime;

            sleepTime = 18 - workTime;
            if(sleepTime < 8) {
                sleepTime = 8;
            }
//            System.out.println(sleepTime+":"+workTime+" / "+(1000/modTime)+"[frame/sec]");
            showStatus("WaitTime:"+sleepTime);

            phase = phTitle;
        }
        monCntr++;
        }
        // システムカウンタの更新
        tick++;
    }

    //========================================================================
    // タイトル表示処理
    //========================================================================
    private void title() {
        // 背景消去
        bg.setColor(titleBgCol);
        bg.fillRect(0, 0, bgWidth, bgHeight);

        if(phase == phTitle) {
            // メッセージ表示
            strDraw("CLICK TO START", textMsgCol, 11.0, 192.0, 0, 1.0, 1.0);
        }

        if(phase == phInit) {
            // メッセージ表示
            String str = Integer.toString((int)(monFrame-monCntr));
            str = "000"+str;
            String str2 = str.substring(str.length() - 3);
            strDraw("WAIT/"+str2, textMsgCol, 65.0, 192.0, 0, 1.0, 1.0);
        }

        double textY = 358.0;
        strDraw("JAVA"+sysJavaVersion, textOsCol, 5.0, textY, 0, 0.5, 0.75); textY += 10;
        strDraw("OS:"+sysOsName+" "+sysOsVersion, textOsCol, 5.0, textY, 0, 0.5, 0.75); textY += 10;
        strDraw("CPU:"+sysOsArch, textOsCol, 5.0, textY, 0, 0.5, 0.75); textY += 10;
    }

    //========================================================================
    // 画面マスク処理
    //========================================================================
    private void maskScreen() {
        bg.setColor(titleBgCol);
        for(int i=0; i<bgHeight/16; i++) {
            for(int j=0; j<bgWidth/16; j++) {
                bg.fillRect(j*16, i*16, 16-filterCnt, 16-filterCnt);
            }
        }
    }

    //========================================================================
    // ゲームオーバー処理
    //========================================================================
    private void gameover() {
        mapRead();

        if(clearFlag) {
            ownMove();
        }

        objMove();
        objDraw();

        if(clearFlag) {
            clearDraw();
        } else {
            goverDraw();
        }
    }

    private void clearDraw() {
        double scale;
        double ofsx;
        int vec;

        strDraw("CONGRATULATIONS", textMsgCol, 34, 160, 0, 0.75, 0.75);

        if(gameoverCnt > 60) {
            strDraw("GAME CLEAR", textMsgCol, 47, 180, 0, 1.0, 1.0);
        }
        if(gameoverCnt > 120) {
            strDraw("CLICK TO REPLAY", textMsgCol, 34.0, 200.0, 0, 0.75, 0.75);
        }
    }

    private void goverDraw() {
        double scale;
        double ofsx;
        int vec;

        if(gameoverCnt < 90) {
            scale = 10.0 - (gameoverCnt/10.0);
            vec = 450 - gameoverCnt*5;
        } else {
            scale = 1.0;
            vec = 0;
        }

//        ofsx = (18.0*scale - 18.0)*4.5-9.0*scale;
        ofsx = 72.0*scale - 81.0;
        strDraw("GAME OVER", textMsgCol, 47.0-ofsx, 180, vec, scale, scale);

        if(gameoverCnt > 90) {
            strDraw("CLICK TO REPLAY", textMsgCol, 34.0, 200.0, 0, 0.75, 0.75);
        }
    }

    //========================================================================
    // プレイ中処理
    //========================================================================
    private void play() {
        mapRead();

        objMove();
        objDraw();
        objCorr();
    }


    //========================================================================
    // マップ情報読み込み処理
    //========================================================================
    private void mapRead() {
        char map;

        if((tick & 0xf) == 0) {
            for(int x=0; x<mapWidth; x++) {
                map = Map.getMap(0, x, mapCntr);
                switch(map) {
                    case 'A':
                        if(x < 8) {
                            enemAMake((int)(x*16.0+8.0), 0.0, 1);
                        } else {
                            enemAMake((int)(x*16.0+8.0), 0.0, 2);
                        }
                        break;
                    case 'B':
                        enemBMake((int)(x*16.0+8.0), 0.0);
                        break;
                    case 'C':
                        if(x < 8) {
                            enemCMake((int)(x*16.0+8.0), 0.0, +0.4, 1.5);
                        } else {
                            enemCMake((int)(x*16.0+8.0), 0.0, -0.4, 1.5);
                        }
                        break;
                    case 'D':
                        enemDMake((int)(x*16.0+8.0), 0.0);
                        break;
                }
            }

            mapCntr++;
            if(mapCntr >= mapHeight) {
                mapCntr = 0;
                level++;
            }

            if(phase == phPlay) {
                remain--;
            }

            if(remain == 0) {
                phase = phGameover;
                clearFlag = true;
            }
        }
    }


    //========================================================================
    // 各オブジェクト作成処理
    //========================================================================
    //
    // 敵弾作成処理
    //
    private void bulletMake(double posx, double posy, int vec) {
        for(int i=0; i<bullet.length; i++) {
            // 空きオブジェクト検索
            if(bullet[i].isDead()) {
                bullet[i].init(posx, posy, vec);
                break;
            }
        }
    }

    //
    // 敵A作成処理
    //
    private void enemAMake(double posx, double posy, int flag) {
        for(int i=0; i<EnemA.getNum(); i++) {
            // 空きオブジェクト検索
            if(eA[i].isDead()) {
                eA[i].init(posx, posy, flag);
                break;
            }
        }
    }

    //
    // 敵B作成処理
    //
    private void enemBMake(double posx, double posy) {
        for(int i=0; i<EnemB.getNum(); i++) {
            // 空きオブジェクト検索
            if(eB[i].isDead()) {
                eB[i].init(posx, posy);
                break;
            }
        }
    }

    //
    // 敵C作成処理
    //
    private void enemCMake(double posx, double posy, double vx, double vy) {
        for(int i=0; i<EnemC.getNum(); i++) {
            // 空きオブジェクト検索
            if(eC[i].isDead()) {
                eC[i].init(posx, posy, vx, vy);
                break;
            }
        }
    }

    //
    // 敵D作成処理
    //
    private void enemDMake(double posx, double posy) {
        for(int i=0; i<EnemD.getNum(); i++) {
            // 空きオブジェクト検索
            if(eD[i].isDead()) {
                eD[i].init(posx, posy);
                break;
            }
        }
    }

    //
    // 火花作成処理
    //
    void sparkMake(double posx, double posy, double vx, double vy, int num) {
        int mkCnt = 0;
        for(int i=0; i<spark.length; i++) {
            // 空きオブジェクト検索
            if(spark[i].isDead()) {
                spark[i].init(posx, posy, MyMath.iRnd(359), MyMath.iRnd(20)-10,
                              vx, vy, MyMath.iRnd(359), MyMath.fRnd(0.8), 10.0);

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

    //
    // 爆風作成処理
    //
    void blastMake(double posx, double posy, double vx, double vy, int num) {
        int mkCnt = 0;

        for(int i=0; i<blast.length; i++) {
            // 空きオブジェクト検索
            if(blast[i].isDead()) {
                blast[i].init(posx, posy, MyMath.iRnd(359), MyMath.iRnd(10)-5,
                              vx, vy, MyMath.iRnd(359), MyMath.fRnd(0.4), 5.0);

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

    //========================================================================
    // オブジェクト移動処理
    //========================================================================
    private void objMove() {
        if(phase == phPlay) {
            ownMove();
        }

        enemAMove();
        enemBMove();
        enemCMove();
        enemDMove();

        objsMove(bullet);
        objsMove(zapper);
        objsMove(blast);
        objsMove(spark);
    }

    //
    // 自機移動処理
    //
    private void ownMove() {

        // 上下移動処理
        if(keyPress[UP] &&(own.getPosY() > 10.0)) {
            own.offsetPos(0.0, -2.0);
        }
        if(keyPress[DOWN] && (own.getPosY() < scrnSzY-10.0)) {
            own.offsetPos(0.0,  2.0);
        }

        // 左右方向移動処理
        if(keyPress[LEFT]) {
            if(ownCrs >= -ownMaxTurnRate) {
                ownCrs -= ownTurnRate;
            }
            if(own.getPosX() > 10.0) {
                own.offsetPos(MyMath.sin(ownCrs)*9.0, 0.0);
            }
        } else if(keyPress[RIGHT]) {
            if(ownCrs <= ownMaxTurnRate) {
                ownCrs += ownTurnRate;
            }
            if(own.getPosX() < scrnSzX-10.0) {
                own.offsetPos(MyMath.sin(ownCrs)*9.0, 0.0);
            }
        } else {
            if(ownCrs > 0) {
                ownCrs -= ownTurnRate;
            }
            if(ownCrs < 0) {
                ownCrs += ownTurnRate;
            }
        }

        // SPACE key押下時処理
        if(keyPress[SPACE] && spKeyCntr == 0) {
            int makeNum = 0;
            int makeIdx = 0;

            // 左右２連射処理
            for(int znum=0; znum<2; znum++) {
                // 発射弾数チェック
                double zx;
                if(znum == 0) {
                    zx = -6.0;
                } else {
                    zx = 6.0;
                }

                // 空きオブジェクト検索
                for(int i=0; i<zapper.length; i++) {
                    if(zapper[i].isDead()) {
                        zapper[i].init(own.getPosX()
                                       + MyMath.sin(ownCrs)*15.0
                                       + MyMath.cos(ownCrs)*zx,
                                       own.getPosY()
                                       - MyMath.cos(ownCrs)*12
                                       + MyMath.sin(ownCrs)*zx,
                                       own.getVecTh(),
                                       own.getVecTh()-90);

                        makeNum++;
                        makeIdx = i;

                        break;
                    }
                }
            }

            if(makeNum == 1) {
                zapper[makeIdx].kill();
            }
        }

        spKeyCntr++;
        if(spKeyCntr > FIRE_INT) {
            spKeyCntr = 0;
        }

        if(own.isDamaged()) {
            own.decDamage();
        }

        own.setVecTh(ownCrs);
    }

    //
    // オブジェクト単純移動処理
    //
    private void objsMove(Motion obj[]) {

        // オブジェクト配列参照
        for(int i=0; i<obj.length; i++) {

            // 生きているオブジェクトのみ移動
            if(obj[i].isAlive()) {
                // 移動処理
                obj[i].move();

                // lifeを1減らす
                obj[i].decLife();
                // 画面外に出たらkillする
                if(obj[i].isRangeOut(0.0, 0.0, scrnSzX, scrnSzY)) {
                    obj[i].kill();
                }
            }
        }
    }

    //
    // 敵A移動処理
    //
    private void enemAMove() {
        for(int i=0; i<EnemA.getNum(); i++) {
            // 生きているオブジェクトのみ移動
            if(eA[i].isAlive()) {

                if(eA[i].getCount() > 30) {
                    if(eA[i].getBehFlag() == 1) {
                        eA[i].mdfVecTh(-2);
                    } else {
                        eA[i].mdfVecTh(2);
                    }
                }

                eA[i].vecMove();
                eA[i].offsetPos(0.0, 1.0);

                if(eA[i].isDamaged()) {
                    eA[i].decDamage();
                }

                // 寿命を1減らす
                eA[i].decLife();

                // 敵弾発射
                if((eA[i].getCount() == 20) || (eA[i].getCount() == 30)
                   || (eA[i].getCount() == 50)) {
                    double ex;
                    double ey;
                    double ox;
                    double oy;
                    ex = eA[i].getPosX();
                    ey = eA[i].getPosY();
                    ox = own.getPosX();
                    oy = own.getPosY();
                    bulletMake(ex, ey,
                             MyMath.getBrg(ex, ey, ox, oy)+MyMath.iRnd(60)-30);
                    if(level >= 1) {
                        bulletMake(ex, ey,
                                 MyMath.getBrg(ex, ey, ox, oy)+MyMath.iRnd(80)-40);
                    }
                    if(level >= 2) {
                        bulletMake(ex, ey,
                                 MyMath.getBrg(ex, ey, ox, oy)+MyMath.iRnd(100)-50);
                    }
                }

                // 画面外に出たらkillする
                if(eA[i].isRangeOut(0.0, 0.0, scrnSzX, scrnSzY)) {
                    eA[i].kill();
                }
            }
        }
    }

    //
    // 敵B移動処理
    //
    private void enemBMove() {
        for(int i=0; i<EnemB.getNum(); i++) {
            // 生きているオブジェクトのみ移動
            if(eB[i].isAlive()) {
                eB[i].move();

                if(eB[i].isDamaged()) {
                    eB[i].decDamage();
                }

                // 寿命を1減らす
                eB[i].decLife();

                if(eB[i].getPosY() > 200.0) {
                    eB[i].setVel(0.0, -4.0);
                    eB[i].setVecTh(270);
                }

                // 敵弾発射
                if((eB[i].getCount() == 10) || (eB[i].getCount() == 20)
                   || (eB[i].getCount() == 50)) {
                    double ex;
                    double ey;
                    double ox;
                    double oy;
                    ex = eB[i].getPosX();
                    ey = eB[i].getPosY();
                    ox = own.getPosX();
                    oy = own.getPosY();
                    bulletMake(ex, ey,
                             MyMath.getBrg(ex, ey, ox, oy)+MyMath.iRnd(60)-30);
                    if(level >= 1) {
                        bulletMake(ex, ey,
                                 MyMath.getBrg(ex, ey, ox, oy)+MyMath.iRnd(80)-40);
                    }
                    if(level >= 2) {
                        bulletMake(ex, ey,
                                 MyMath.getBrg(ex, ey, ox, oy)+MyMath.iRnd(100)-50);
                    }
                }

                // 画面外に出たらkillする
                if(eB[i].isRangeOut(0.0, 0.0, scrnSzX, scrnSzY)) {
                    eB[i].kill();
                }
            }
        }
    }

    //
    // 敵C移動処理
    //
    private void enemCMove() {
        for(int i=0; i<EnemC.getNum(); i++) {
            // 生きているオブジェクトのみ移動
            if(eC[i].isAlive()) {
                eC[i].move();

                if(eC[i].isDamaged()) {
                    eC[i].decDamage();
                }

                // 寿命を1減らす
                eC[i].decLife();

                // 画面外に出たらkillする
                if(eC[i].isRangeOut(0.0, 0.0, scrnSzX, scrnSzY)) {
                    eC[i].kill();
                }
            }
        }
    }

    //
    // 敵D移動処理
    //
    private void enemDMove() {
        double vx;

        for(int i=0; i<EnemD.getNum(); i++) {
            // 生きているオブジェクトのみ移動
            if(eD[i].isAlive()) {
                eD[i].move();

                if(eD[i].isDamaged()) {
                    eD[i].decDamage();
                }

                // 寿命を1減らす
                eD[i].decLife();

                vx = eD[i].getVX();
                if(eD[i].getPosX() < (scrnSzX / 2)) {
                    vx = vx+0.05;
                } else {
                    vx = vx-0.05;
                }
                eD[i].setVel(vx, 1.0);

                // 画面外に出たらkillする
                if(eD[i].isRangeOut(0.0, 0.0, scrnSzX, scrnSzY)) {
                    eD[i].kill();
                }
            }
        }
    }


    //========================================================================
    // オブジェクト衝突判定処理
    //========================================================================
    private void objCorr() {
        zapCorr();
        ownCorr();
    }

    //
    // 自機当たり判定処理
    //
    private void ownCorr() {
        ownChk(bullet, true);
        ownChk(eA, true);
        ownChk(eB, true);
        ownChk(eC, true);
        ownChk(eD, true);
    }
    private void ownChk(Enemy enem[], boolean killFlag) {
        // 敵配列参照
        for(int i=0; i<enem.length; i++) {
            // 生きているならば
            if(enem[i].isAlive()) {
                // オブジェクト同士衝突判定
                if(jdgCorr(own, enem[i])) {
                    own.setDamage(8);
                    own.mdfHp(-enem[i].getPow());

                    if(own.getHp() < 0) {
                        blastMake(own.getPosX(), own.getPosY(),
                                  enem[i].getVX()*0.7,
                                  enem[i].getVY()*0.7,
                                  20);
                        phase = phGameover;
                        gameoverCnt = 0;
                    }

                    // 破片作成
                    sparkMake(own.getPosX(), own.getPosY(),
                              (own.getVX()+enem[i].getVX())*0.5,
                              (own.getVY()+enem[i].getVY())*0.5, 10);
                    if(killFlag) {
                        enem[i].kill();
                    }
                    break;
                }
            }
        }
    }

    //
    // 自機弾当たり判定処理
    //
    private void zapCorr() {
        for(int i=0; i<zapper.length; i++) {
            if(zapper[i].isAlive()) {
                zapChk(zapper[i], eA);
            }
            if(zapper[i].isAlive()) {
                zapChk(zapper[i], eB);
            }
            if(zapper[i].isAlive()) {
                zapChk(zapper[i], eC);
            }
            if(zapper[i].isAlive()) {
                zapChk(zapper[i], eD);
            }
        }
    }

    private void zapChk(Motion zap, Enemy enem[]) {
        // 敵配列参照
        for(int i=0; i<enem.length; i++) {
            // 生きているならば
            if(enem[i].isAlive()) {
                // オブジェクト同士衝突判定
                if(jdgCorr(zap, enem[i])) {
                    // 破片作成
                    sparkMake(zap.getPosX(), zap.getPosY(),
                            (zap.getVX()+enem[i].getVX())*0.5,
                            (zap.getVY()+enem[i].getVY())*0.15, 10);

                    // 自機弾kill
                    zap.kill();

                    // 敵ダメージ設定
                    enem[i].setDamage(4);

                    // 敵耐久力減
                    enem[i].decHp();

                    // 敵破壊処理
                    if(enem[i].isDead()) {
                        int pts;

                        // 得点計算
                        pts = enem[i].getPts();
                        score += pts;

                        // 爆風作成
                        blastMake(zap.getPosX(), zap.getPosY(),
                                 (enem[i].getVX())*0.3,
                                 (enem[i].getVY())*0.3, 6);
                    }
                    break;
                }
            }
        }
    }

    //========================================================================
    // オブジェクト衝突判定
    //   true  : 衝突
    //   false : 非衝突
    //========================================================================
    private final boolean jdgCorr(Motion a, Motion b) {
        boolean result;
        double dist;
        double dx;
        double dy;

        dx = a.getPosX() - b.getPosX();
        dy = a.getPosY() - b.getPosY();

        dist = Math.sqrt(dx*dx + dy*dy);

        if(dist < (a.getSize() + b.getSize())) {
            result = true;
        } else {
            result = false;
        }

        return result;
    }

    //========================================================================
    // 各オブジェクト描画処理
    //========================================================================
    private void objDraw() {
        // 背景消去
        bgErase();

        // 背景描画
        bgDraw();

        // 爆風描画
        for(int i=0; i<blast.length; i++) {
            if(blast[i].isAlive()) { blast[i].draw(bg); }
        }

        // 自機弾描画
        for(int i=0; i<zapper.length; i++) {
            if(zapper[i].isAlive()) { zapper[i].draw(bg); }
        }

        // 敵弾描画
        for(int i=0; i<bullet.length; i++) {
            if(bullet[i].isAlive()) { bullet[i].draw(bg); }
        }

        // 敵A描画
        for(int i=0; i<eA.length; i++) {
            if(eA[i].isAlive()) {
                if(eA[i].isDamaged()) {
                    eA[i].draw(bg, flickCol);
                } else {
                    eA[i].draw(bg);
                }
            }
        }
        // 敵B描画
        for(int i=0; i<eB.length; i++) {
            if(eB[i].isAlive()) {
                if(eB[i].isDamaged()) {
                    eB[i].draw(bg, flickCol);
                } else {
                    eB[i].draw(bg);
                }
            }
        }
        // 敵C描画
        for(int i=0; i<eC.length; i++) {
            if(eC[i].isAlive()) {
                if(eC[i].isDamaged()) {
                    eC[i].draw(bg, flickCol);
                } else {
                    eC[i].draw(bg);
                }
            }
        }
        // 敵D描画
        for(int i=0; i<eD.length; i++) {
            if(eD[i].isAlive()) {
                if(eD[i].isDamaged()) {
                    eD[i].draw(bg, flickCol);
                } else {
                    eD[i].draw(bg);
                }
            }
        }

        // 自機描画
        if((phase == phPlay) || ((phase == phGameover) && clearFlag)) {
            if(own.isDamaged()) {
                own.draw(bg, flickCol);
            } else {
                own.draw(bg);
            }
        }
        // 火花描画
        for(int i=0; i<spark.length; i++) {
            if(spark[i].isAlive()) { spark[i].draw(bg, flickCol); }
        }

        // 得点描画
        scoreDraw();
    }

    //
    // 画面消去
    //
    private void bgErase() {
        bg.setColor(bgCol);
        bg.fillRect(0, 0, bgWidth, bgHeight);
    }

    //
    // 得点表示
    //
    private int hpPosX = 0;
    private int hpPosY = 17;
    private void scoreDraw() {
        String scoreStr = Integer.toString(score);
        scoreStr = "000000"+scoreStr;
        String scoreStr2 = scoreStr.substring(scoreStr.length() - 7);
        strDraw(scoreStr2, 10.0, 8.0);

        String remainStr = Integer.toString(remain);
        remainStr = "000"+remainStr;
        String remainStr2 = remainStr.substring(remainStr.length() - 3);
        strDraw("TIME:"+remainStr2, 10.0, 377.0);

        // HP表示
        bg.setColor(Color.white);
        bg.drawRect(hpPosX, hpPosY, ownHp, 7);
        if(phase == phPlay) {
            int hp;

            hp = own.getHp()-3;
            if(hp < 0) {
                hp = 0;
            }

            bg.setColor(ownHpCol[((ownHpColG-1)*hp/ownHp)]);
            bg.fillRect(hpPosX+2, hpPosY+2, hp, 4);
        }
    }

    //
    // 背景描画
    //
    private void bgDraw() {
        bgScr += 1;
        bgScr = bgScr & 0x1f;

        bg.setColor(grdCol);
        for(int x=0; x<bgWidth; x+=32) {
            bg.drawLine(x, 0, x, bgHeight);
        }
        bg.drawLine(bgWidth-1, 0, bgWidth-1, bgHeight);
        for(int y=0; y<bgHeight; y+=32) {
            bg.drawLine(0, y+bgScr, bgWidth, y+bgScr);
        }
    }

    //
    // 文字列描画
    //
    private void strDraw(
        String str,
        Color col,
        double posx,
        double posy,
        int vec,
        double scX,
        double scY
    ) {
        char ch;

        for(int i=0; i<str.length(); i++) {
            ch = str.charAt(i);
            Pict.draw((int)ch, bg, col, posx+i*18*scX, posy, vec, scX, scY);
        }
    }

    private void strDraw(String str, double posx, double posy) {
        char ch;

        for(int i=0; i<str.length(); i++) {
            ch = str.charAt(i);
            Pict.draw((int)ch, bg, posx+i*18, posy);
        }
    }

    //========================================================================
    // イベントリスナ登録
    // KeyListener Method
    //========================================================================
    // キーを押したとき
    public void keyPressed(KeyEvent e) {
        switch(e.getKeyCode()) {
            case KeyEvent.VK_I:
            case KeyEvent.VK_UP:
            case KeyEvent.VK_NUMPAD8:
                keyPress[UP] = true;
                keyPress[DOWN] = false;
                break;
            case KeyEvent.VK_M:
            case KeyEvent.VK_DOWN:
            case KeyEvent.VK_NUMPAD2:
                keyPress[DOWN] = true;
                keyPress[UP] = false;
                break;
            case KeyEvent.VK_J:
            case KeyEvent.VK_LEFT:
            case KeyEvent.VK_NUMPAD4:
                keyPress[LEFT] = true;
                keyPress[RIGHT] = false;
                break;
            case KeyEvent.VK_L:
            case KeyEvent.VK_RIGHT:
            case KeyEvent.VK_NUMPAD6:
                keyPress[RIGHT] = true;
                keyPress[LEFT] = false;
                break;
            case KeyEvent.VK_SPACE:
                keyPress[SPACE] = true;
                break;
        }
    }

    // キーを離したとき
    public void keyReleased(KeyEvent e) {
        switch(e.getKeyCode()) {
            case KeyEvent.VK_I:
            case KeyEvent.VK_UP:
            case KeyEvent.VK_NUMPAD8:
                keyPress[UP] = false;
                break;
            case KeyEvent.VK_M:
            case KeyEvent.VK_DOWN:
            case KeyEvent.VK_NUMPAD2:
                keyPress[DOWN] = false;
                break;
            case KeyEvent.VK_J:
            case KeyEvent.VK_LEFT:
            case KeyEvent.VK_NUMPAD4:
                keyPress[LEFT] = false;
                break;
            case KeyEvent.VK_L:
            case KeyEvent.VK_RIGHT:
            case KeyEvent.VK_NUMPAD6:
                keyPress[RIGHT] = false;
                break;
            case KeyEvent.VK_SPACE:
                keyPress[SPACE] = false;
                break;
        }
    }

    public void keyTyped(KeyEvent e) {
    }


    //========================================================================
    // イベントリスナ登録
    // MouseListener Method
    //========================================================================
    public void mouseClicked(MouseEvent e) {
        // マウスクリック
        if(phase == phTitle) {
            phase = phPlay;

            filterCnt = 0;
        }
        if(phase == phGameover) {
            phase = phTitle;

            initState();
        }
    }

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

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

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

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

import java.awt.*;

public class Plate {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private int    ptNum;        // 頂点数
    private Color  color;        // 表示色
    private int    style;        // 表示スタイル
    private double shape[][];    // 形状
    private int    dispX[];      // 表示用ｘ座標列
    private int    dispY[];      // 表示用ｙ座標列

    public static final int LINE = 0;   // 描画スタイル:線画
    public static final int FILL = 1;   // 描画スタイル:塗りつぶし
    public static final int LNFL = 2;   // 描画スタイル:線画＋塗りつぶし

    //========================================================================
    // コンストラクタ
    //========================================================================
    public Plate(
        Color  col,    // 表示色
        int    style,  // 表示スタイル
        double sh[][]  // 形状
    ) {
        this.color = col;
        this.style = style;
        this.ptNum = sh.length;
        this.shape = sh;

        dispX = new int[ptNum];
        dispY = new int[ptNum];
    }

    //========================================================================
    // Method
    //========================================================================
    // 表示色指定描画処理
    public final void draw(
        Graphics g,     // 表示対象Graphics
        Color    col,   // 表示色
        double x,       // 表示ｘ座標
        double y,       // 表示ｙ座標
        int vec,        // 表示方位
        double sc       // 表示スケール
    ) {
        draw(g, col, x, y, vec, sc, sc);
    }

    // 表示色指定描画処理
    public final void draw(
        Graphics g,     // 表示対象Graphics
        Color    col,   // 表示色
        double x,       // 表示ｘ座標
        double y,       // 表示ｙ座標
        int vec,        // 表示方位
        double scX,     // 表示スケールｘ
        double scY      // 表示スケールｙ
    ) {
        double tmpSin = MyMath.sin(vec); // sin値
        double tmpCos = MyMath.cos(vec); // cos値

        // 描画座標計算処理
        for(int i=0; i<ptNum; i++) {
            dispX[i] = (int)(x + (shape[i][0]*tmpCos*scX -
                                  shape[i][1]*tmpSin*scY));
            dispY[i] = (int)(y + (shape[i][0]*tmpSin*scX +
                                  shape[i][1]*tmpCos*scY));
        }

        // 描画処理
        g.setColor(col);
        switch (style) {
            case LINE:
                // 描画スタイル:線画
                g.setColor(col);
                g.drawPolyline(dispX, dispY, ptNum);
                break;

            case FILL:
                // 描画スタイル:塗りつぶし
                g.setColor(col);
                g.fillPolygon(dispX, dispY, ptNum);
                break;

            case LNFL:
                // 描画スタイル:線画＋塗りつぶし
                g.setColor(rdcCol(col));
                g.fillPolygon(dispX, dispY, ptNum);

                g.setColor(col);
                g.drawPolyline(dispX, dispY, ptNum);
                break;

            default:
                break;
        }
    }

    // 既定色描画処理
    public final void draw(
        Graphics g,     // 表示対象Graphics
        double x,       // 表示ｘ座標
        double y,       // 表示ｙ座標
        int vec,        // 表示方位
        double sc       // 表示スケール
    ) {
        draw(g, this.color, x, y, vec, sc);
    }

    // 色変換処理(輝度落とす)
    private final Color rdcCol(
        Color col       // 基準色
    ) {
        Color res;
        int colR;
        int colG;
        int colB;

        colR = col.getRed();
        colG = col.getGreen();
        colB = col.getBlue();

        colR = colR / 2;
        colG = colG / 2;
        colB = colB / 2;

        res = new Color((colR << 16) + (colG << 8) + colB);

        return res;
    }
}

import java.awt.*;

final public class Pict {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static final int cellNum = 128;  // 総Pict数
    private static final int pNum[];         // 各Pict構成Plate数
    private static Plate plate[][];          // 各Pict構成Plate配列

    private static final double shape[][][][] = {         // 形状
        // Pict:00-31
        {{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},
        {{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},
        {{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},
        {{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},

        // Pict:32 " "
        {
            {
                {-8.0,  1.0},{-8.0,  5.0},{ 7.0,  5.0},{ 7.0,  1.0},
                { 5.0,  1.0},{ 5.0,  3.0},{-6.0,  3.0},{-6.0,  1.0},
                {-8.0,  1.0},
            }
        },
        // Pict:33-45
        {{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},
        // Pict:40 "("
        {
            {
                {-4.0, -2.0},{-4.0,  2.0},{-1.0,  5.0},{ 4.0,  5.0},
                { 1.0,  2.0},{ 1.0, -2.0},{ 4.0, -5.0},{-1.0, -5.0},
                {-4.0, -2.0},
            }
        },
        // Pict:41 ")"
        {
            {
                {-5.0, -5.0},{-2.0, -2.0},{-2.0,  2.0},{-5.0,  5.0},
                { 0.0,  5.0},{ 3.0,  2.0},{ 3.0, -2.0},{ 0.0, -5.0},
                {-5.0, -5.0},
            }
        },
        {{{}}},{{{}}},{{{}}},{{{}}},
        // Pict:46 "."
        {
            {
                {-3.0,  3.0},{-3.0,  5.0},{ 2.0,  5.0},{ 2.0,  3.0},
                {-3.0,  3.0},
            }
        },
        // Pict:47 "/"
        {
            {
                {-8.0,  5.0},{ 2.0, -5.0},{ 7.0, -5.0},{-3.0,  5.0},
                {-8.0,  5.0},
            }
        },
        // Pict:48 "0"
        {
            {
                {-6.0, -3.0},{-8.0, -1.0},{-8.0,  3.0},{-6.0,  5.0},
                { 5.0,  5.0},{ 7.0,  3.0},{ 7.0, -1.0},{ 5.0, -3.0},
                {-1.0, -3.0},{-1.0, -1.0},{ 2.0, -1.0},{ 2.0,  3.0},
                {-3.0,  3.0},{-3.0, -3.0},{-6.0, -3.0},
            }
        },
        // Pict:49 "1"
        {
            {
                {-3.0, -3.0},{-3.0,  5.0},{ 2.0,  5.0},{ 2.0, -5.0},
                {-1.0, -5.0},{-3.0, -3.0},
            }
        },
        // Pict:50 "2"
        {
            {
                {-8.0,  5.0},{ 7.0,  5.0},{ 7.0,  3.0},{-3.0,  3.0},
                {-3.0,  1.0},{ 5.0,  1.0},{ 7.0, -1.0},{ 7.0, -3.0},
                { 5.0, -5.0},{-8.0, -5.0},{-8.0, -3.0},{ 2.0, -3.0},
                { 2.0, -1.0},{-6.0, -1.0},{-8.0,  1.0},{-8.0,  5.0},
            }
        },
        // Pict:51 "3"
        {
            {
                {-8.0, -5.0},{-8.0, -3.0},{ 2.0, -3.0},{ 2.0, -1.0},
                {-6.0, -1.0},{-6.0,  1.0},{ 2.0,  1.0},{ 2.0,  3.0},
                {-8.0,  3.0},{-8.0,  5.0},{ 5.0,  5.0},{ 7.0,  3.0},
                { 7.0, -3.0},{ 5.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:52 "4"
        {
            {
                {-6.0, -5.0},{-8.0, -3.0},{-8.0,  2.0},{ 2.0,  2.0},
                { 2.0,  5.0},{ 7.0,  5.0},{ 7.0, -5.0},{ 2.0, -5.0},
                { 2.0,  0.0},{-3.0,  0.0},{-3.0, -5.0},{-6.0, -5.0},
            }
        },
        // Pict:53 "5"
        {
            {
                {-8.0, -5.0},{-8.0,  1.0},{ 2.0,  1.0},{ 2.0,  3.0},
                {-8.0,  3.0},{-8.0,  5.0},{ 5.0,  5.0},{ 7.0,  3.0},
                { 7.0,  1.0},{ 5.0, -1.0},{-3.0, -1.0},{-3.0, -3.0},
                { 7.0, -3.0},{ 7.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:54 "6"
        {
            {
                {-8.0, -3.0},{-8.0,  3.0},{-6.0,  5.0},{ 5.0,  5.0},
                { 7.0,  3.0},{ 7.0,  1.0},{ 5.0, -1.0},{-1.0, -1.0},
                {-1.0,  1.0},{ 2.0,  1.0},{ 2.0,  3.0},{-3.0,  3.0},
                {-3.0, -3.0},{ 5.0, -3.0},{ 5.0, -5.0},{-6.0, -5.0},
                {-8.0, -3.0},
            }
        },
        // Pict:55 "7"
        {
            {
                {-8.0, -5.0},{-8.0, -3.0},{ 2.0, -3.0},{ 2.0, -1.0},
                {-2.0, -1.0},{-4.0,  1.0},{-4.0,  5.0},{ 1.0,  5.0},
                { 1.0,  1.0},{ 5.0,  1.0},{ 7.0, -1.0},{ 7.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:56 "8"
        {
            {
                {-6.0, -5.0},{-8.0, -3.0},{-8.0, -2.0},{-6.0,  0.0},
                {-8.0,  2.0},{-8.0,  3.0},{-6.0,  5.0},{ 0.0,  5.0},
                { 0.0,  3.0},{-3.0,  3.0},{-3.0,  1.0},{ 2.0,  1.0},
                { 2.0,  5.0},{ 5.0,  5.0},{ 7.0,  3.0},{ 7.0,  2.0},
                { 5.0,  0.0},{ 7.0, -2.0},{ 7.0, -3.0},{ 5.0, -5.0},
                {-1.0, -5.0},{-1.0, -3.0},{ 2.0, -3.0},{ 2.0, -1.0},
                {-3.0, -1.0},{-3.0, -5.0},{-6.0, -5.0}
            }
        },
        // Pict:57 "9"
        {
            {
                {-8.0, -3.0},{-8.0, -1.0},{-6.0,  1.0},{ 0.0,  1.0},
                { 0.0, -1.0},{-3.0, -1.0},{-3.0, -3.0},{ 2.0, -3.0},
                { 2.0,  3.0},{-6.0,  3.0},{-6.0,  5.0},{ 5.0,  5.0},
                { 7.0,  3.0},{ 7.0, -3.0},{ 5.0, -5.0},{-6.0, -5.0},
                {-8.0, -3.0},
            }
        },
        // Pict:58 ":"
        {
            {
                {-3.0, -4.0},{-3.0, -1.0},{-2.0, -1.0},{-2.0,  1.0},
                {-3.0,  1.0},{-3.0,  4.0},{ 2.0,  4.0},{ 2.0,  1.0},
                { 0.0,  1.0},{ 0.0, -1.0},{ 2.0, -1.0},{ 2.0, -4.0},
                {-3.0, -4.0},
            }
        },
        // Pict:59-64
        {{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},
        // Pict:65 "A"
        {
            {
                {-8.0, -3.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0, -3.0},
                { 2.0, -3.0},{ 2.0,  1.0},{-1.0,  1.0},{-1.0,  3.0},
                { 2.0,  3.0},{ 2.0,  5.0},{ 7.0,  5.0},{ 7.0, -3.0},
                { 5.0, -5.0},{-6.0, -5.0},{-8.0, -3.0},
            }
        },
        // Pict:66 "B"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{ 0.0,  5.0},{ 0.0,  3.0},
                {-3.0,  3.0},{-3.0,  1.0},{ 2.0,  1.0},{ 2.0,  5.0},
                { 5.0,  5.0},{ 7.0,  3.0},{ 7.0,  2.0},{ 5.0,  0.0},
                { 7.0, -2.0},{ 7.0, -3.0},{ 5.0, -5.0},{-1.0, -5.0},
                {-1.0, -3.0},{ 2.0, -3.0},{ 2.0, -1.0},{-3.0, -1.0},
                {-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:67 "C"
        {
            {
                {-8.0, -3.0},{-8.0,  3.0},{-6.0,  5.0},{ 7.0,  5.0},
                { 7.0,  3.0},{-3.0,  3.0},{-3.0, -3.0},{ 7.0, -3.0},
                { 7.0, -5.0},{-6.0, -5.0},{-8.0, -3.0},
            }
        },
        // Pict:68 "D"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{ 5.0,  5.0},{ 7.0,  3.0},
                { 7.0, -3.0},{ 5.0, -5.0},{-1.0, -5.0},{-1.0, -3.0},
                { 2.0, -3.0},{ 2.0,  3.0},{-3.0,  3.0},{-3.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:69 "E"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{ 7.0,  5.0},{ 7.0,  3.0},
                {-3.0,  3.0},{-3.0,  1.0},{ 5.0,  1.0},{ 5.0, -1.0},
                {-3.0, -1.0},{-3.0, -3.0},{ 7.0, -3.0},{ 7.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:70 "F"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0,  1.0},
                { 5.0,  1.0},{ 5.0, -1.0},{-3.0, -1.0},{-3.0, -3.0},
                { 7.0, -3.0},{ 7.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:71 "G"
        {
            {
                {-8.0, -3.0},{-8.0,  3.0},{-6.0,  5.0},{ 7.0,  5.0},
                { 7.0, -1.0},{ 0.0, -1.0},{ 0.0,  1.0},{ 2.0,  1.0},
                { 2.0,  3.0},{-3.0,  3.0},{-3.0, -3.0},{ 7.0, -3.0},
                { 7.0, -5.0},{-6.0, -5.0},{-8.0, -3.0},
            }
        },
        // Pict:72 "H"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0,  1.0},
                { 2.0,  1.0},{ 2.0,  5.0},{ 7.0,  5.0},{ 7.0, -5.0},
                { 2.0, -5.0},{ 2.0, -1.0},{-3.0, -1.0},{-3.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:73 "I"
        {
            {
                {-5.0, -5.0},{-5.0, -3.0},{-3.0, -3.0},{-3.0,  3.0},
                {-5.0,  3.0},{-5.0,  5.0},{ 4.0,  5.0},{ 4.0,  3.0},
                { 2.0,  3.0},{ 2.0, -3.0},{ 4.0, -3.0},{ 4.0, -5.0},
                {-5.0, -5.0},
            }
        },
        // Pict:74 "J"
        {
            {
                { 2.0, -5.0},{ 2.0,  3.0},{-3.0,  3.0},{-3.0,  1.0},
                {-8.0,  1.0},{-8.0,  3.0},{-6.0,  5.0},{ 5.0,  5.0},
                { 7.0,  3.0},{ 7.0, -5.0},{ 2.0, -5.0},
            }
        },
        // Pict:75 "K"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0,  0.0},
                { 2.0,  5.0},{ 7.0,  5.0},{ 2.0,  0.0},{ 7.0, -5.0},
                { 2.0, -5.0},{-3.0,  0.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:76 "L"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{ 7.0,  5.0},{ 7.0,  3.0},
                {-3.0,  3.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:77 "M"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0, -2.0},
                {-1.0,  0.0},{ 0.0,  0.0},{ 2.0, -2.0},{ 2.0,  5.0},
                { 7.0,  5.0},{ 7.0, -5.0},{ 2.0, -5.0},{ 0.0, -3.0},
                {-1.0, -3.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:78 "N"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0, -1.0},
                { 2.0,  4.0},{ 2.0,  5.0},{ 7.0,  5.0},{ 7.0, -5.0},
                { 2.0, -5.0},{ 2.0,  1.0},{-3.0, -4.0},{-3.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:79 "O"
        {
            {
                {-8.0, -3.0},{-8.0,  3.0},{-6.0,  5.0},{ 5.0,  5.0},
                { 7.0,  3.0},{ 7.0, -3.0},{ 5.0, -5.0},{-1.0, -5.0},
                {-1.0, -3.0},{ 2.0, -3.0},{ 2.0,  3.0},{-3.0,  3.0},
                {-3.0, -5.0},{-6.0, -5.0},{-8.0, -3.0},
            }
        },
        // Pict:80 "P"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0, -3.0},
                { 2.0, -3.0},{ 2.0,  1.0},{-1.0,  1.0},{-1.0,  3.0},
                { 5.0,  3.0},{ 7.0,  1.0},{ 7.0, -3.0},{ 5.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:81 "Q"
        {
            {
                {-8.0, -3.0},{-8.0,  3.0},{-6.0,  5.0},{ 1.0,  5.0},
                {-1.0,  3.0},{-3.0,  3.0},{-3.0, -3.0},{ 2.0, -3.0},
                { 2.0,  1.0},{ 0.0,  1.0},{ 4.0,  5.0},{ 7.0,  5.0},
                { 5.0,  3.0},{ 7.0,  1.0},{ 7.0, -3.0},{ 5.0, -5.0},
                {-6.0, -5.0},{-8.0, -3.0},
            }
        },
        // Pict:82 "R"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0, -3.0},
                { 2.0, -3.0},{ 2.0,  0.0},{-1.0,  0.0},{-1.0,  2.0},
                { 2.0,  5.0},{ 7.0,  5.0},{ 4.0,  2.0},{ 5.0,  2.0},
                { 7.0,  0.0},{ 7.0, -3.0},{ 5.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:83 "S"
        {
            {
                {-8.0, -3.0},{-8.0, -1.0},{-6.0,  1.0},{ 2.0,  1.0},
                { 2.0,  3.0},{-8.0,  3.0},{-8.0,  5.0},{ 5.0,  5.0},
                { 7.0,  3.0},{ 7.0,  1.0},{ 5.0, -1.0},{-3.0, -1.0},
                {-3.0, -3.0},{ 7.0, -3.0},{ 7.0, -5.0},{-6.0, -5.0},
                {-8.0, -3.0},
            }
        },
        // Pict:84 "T"
        {
            {
                {-8.0, -5.0},{-8.0, -3.0},{-3.0, -3.0},{-3.0,  5.0},
                { 2.0,  5.0},{ 2.0, -3.0},{ 7.0, -3.0},{ 7.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:85 "U"
        {
            {
                {-8.0, -5.0},{-8.0,  3.0},{-6.0,  5.0},{ 5.0,  5.0},
                { 7.0,  3.0},{ 7.0, -5.0},{ 2.0, -5.0},{ 2.0,  3.0},
                {-3.0,  3.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:86 "V"
        {
            {
                {-8.0, -5.0},{-8.0,  0.0},{-3.0,  5.0},{ 2.0,  5.0},
                { 7.0,  0.0},{ 7.0, -5.0},{ 2.0, -5.0},{ 2.0,  0.0},
                { 0.0,  2.0},{-1.0,  2.0},{-3.0,  0.0},{-3.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:87 "W"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-1.0,  3.0},
                { 0.0,  3.0},{ 2.0,  5.0},{ 7.0,  5.0},{ 7.0, -5.0},
                { 2.0, -5.0},{ 2.0,  2.0},{ 0.0,  0.0},{-1.0,  0.0},
                {-3.0,  2.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:88 "X"
        {
            {
                {-8.0, -5.0},{-8.0, -4.0},{-4.0,  0.0},{-8.0,  4.0},
                {-8.0,  5.0},{-3.0,  5.0},{-3.0,  4.0},{-1.0,  2.0},
                { 0.0,  2.0},{ 2.0,  4.0},{ 2.0,  5.0},{ 7.0,  5.0},
                { 7.0,  4.0},{ 3.0,  0.0},{ 7.0, -4.0},{ 7.0, -5.0},
                { 2.0, -5.0},{ 2.0, -4.0},{ 0.0, -2.0},{-1.0, -2.0},
                {-3.0, -4.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:89 "Y"
        {
            {
                {-8.0, -5.0},{-8.0, -3.0},{-3.0,  2.0},{-3.0,  5.0},
                { 2.0,  5.0},{ 2.0,  2.0},{ 7.0, -3.0},{ 7.0, -5.0},
                { 2.0, -5.0},{ 2.0, -3.0},{ 0.0, -1.0},{-1.0, -1.0},
                {-3.0, -3.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:90 "Z"
        {
            {
                {-8.0, -5.0},{-8.0, -3.0},{ 2.0, -3.0},{ 0.0, -1.0},
                {-4.0, -1.0},{-8.0,  3.0},{-8.0,  5.0},{ 7.0,  5.0},
                { 7.0,  3.0},{-3.0,  3.0},{-1.0,  1.0},{ 3.0,  1.0},
                { 7.0, -3.0},{ 7.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:91-96
        {{{}}},{{{}}},{{{}}},{{{}}},{{{}}},{{{}}},
        // Pict:97 "a"
        {
            {
                {-8.0, -3.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0, -3.0},
                { 2.0, -3.0},{ 2.0,  1.0},{-1.0,  1.0},{-1.0,  3.0},
                { 2.0,  3.0},{ 2.0,  5.0},{ 7.0,  5.0},{ 7.0, -3.0},
                { 5.0, -5.0},{-6.0, -5.0},{-8.0, -3.0},
            }
        },
        // Pict:98 "b"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{ 0.0,  5.0},{ 0.0,  3.0},
                {-3.0,  3.0},{-3.0,  1.0},{ 2.0,  1.0},{ 2.0,  5.0},
                { 5.0,  5.0},{ 7.0,  3.0},{ 7.0,  2.0},{ 5.0,  0.0},
                { 7.0, -2.0},{ 7.0, -3.0},{ 5.0, -5.0},{-1.0, -5.0},
                {-1.0, -3.0},{ 2.0, -3.0},{ 2.0, -1.0},{-3.0, -1.0},
                {-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:99 "c"
        {
            {
                {-8.0, -3.0},{-8.0,  3.0},{-6.0,  5.0},{ 7.0,  5.0},
                { 7.0,  3.0},{-3.0,  3.0},{-3.0, -3.0},{ 7.0, -3.0},
                { 7.0, -5.0},{-6.0, -5.0},{-8.0, -3.0},
            }
        },
        // Pict:100 "d"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{ 5.0,  5.0},{ 7.0,  3.0},
                { 7.0, -3.0},{ 5.0, -5.0},{-1.0, -5.0},{-1.0, -3.0},
                { 2.0, -3.0},{ 2.0,  3.0},{-3.0,  3.0},{-3.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:101 "e"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{ 7.0,  5.0},{ 7.0,  3.0},
                {-3.0,  3.0},{-3.0,  1.0},{ 5.0,  1.0},{ 5.0, -1.0},
                {-3.0, -1.0},{-3.0, -3.0},{ 7.0, -3.0},{ 7.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:102 "f"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0,  1.0},
                { 5.0,  1.0},{ 5.0, -1.0},{-3.0, -1.0},{-3.0, -3.0},
                { 7.0, -3.0},{ 7.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:103 "g"
        {
            {
                {-8.0, -3.0},{-8.0,  3.0},{-6.0,  5.0},{ 7.0,  5.0},
                { 7.0, -1.0},{ 0.0, -1.0},{ 0.0,  1.0},{ 2.0,  1.0},
                { 2.0,  3.0},{-3.0,  3.0},{-3.0, -3.0},{ 7.0, -3.0},
                { 7.0, -5.0},{-6.0, -5.0},{-8.0, -3.0},
            }
        },
        // Pict:104 "h"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0,  1.0},
                { 2.0,  1.0},{ 2.0,  5.0},{ 7.0,  5.0},{ 7.0, -5.0},
                { 2.0, -5.0},{ 2.0, -1.0},{-3.0, -1.0},{-3.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:105 "i"
        {
            {
                {-5.0, -5.0},{-5.0, -3.0},{-3.0, -3.0},{-3.0,  3.0},
                {-5.0,  3.0},{-5.0,  5.0},{ 4.0,  5.0},{ 4.0,  3.0},
                { 2.0,  3.0},{ 2.0, -3.0},{ 4.0, -3.0},{ 4.0, -5.0},
                {-5.0, -5.0},
            }
        },
        // Pict:106 "j"
        {
            {
                { 2.0, -5.0},{ 2.0,  3.0},{-3.0,  3.0},{-3.0,  1.0},
                {-8.0,  1.0},{-8.0,  3.0},{-6.0,  5.0},{ 5.0,  5.0},
                { 7.0,  3.0},{ 7.0, -5.0},{ 2.0, -5.0},
            }
        },
        // Pict:107 "k"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0,  0.0},
                { 2.0,  5.0},{ 7.0,  5.0},{ 2.0,  0.0},{ 7.0, -5.0},
                { 2.0, -5.0},{-3.0,  0.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:108 "l"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{ 7.0,  5.0},{ 7.0,  3.0},
                {-3.0,  3.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:109 "m"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0, -2.0},
                {-1.0,  0.0},{ 0.0,  0.0},{ 2.0, -2.0},{ 2.0,  5.0},
                { 7.0,  5.0},{ 7.0, -5.0},{ 2.0, -5.0},{ 0.0, -3.0},
                {-1.0, -3.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:110 "n"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0, -1.0},
                { 2.0,  4.0},{ 2.0,  5.0},{ 7.0,  5.0},{ 7.0, -5.0},
                { 2.0, -5.0},{ 2.0,  1.0},{-3.0, -4.0},{-3.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:111 "o"
        {
            {
                {-8.0, -3.0},{-8.0,  3.0},{-6.0,  5.0},{ 5.0,  5.0},
                { 7.0,  3.0},{ 7.0, -3.0},{ 5.0, -5.0},{-1.0, -5.0},
                {-1.0, -3.0},{ 2.0, -3.0},{ 2.0,  3.0},{-3.0,  3.0},
                {-3.0, -5.0},{-6.0, -5.0},{-8.0, -3.0},
            }
        },
        // Pict:112 "p"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0, -3.0},
                { 2.0, -3.0},{ 2.0,  1.0},{-1.0,  1.0},{-1.0,  3.0},
                { 5.0,  3.0},{ 7.0,  1.0},{ 7.0, -3.0},{ 5.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:113 "q"
        {
            {
                {-8.0, -3.0},{-8.0,  3.0},{-6.0,  5.0},{ 1.0,  5.0},
                {-1.0,  3.0},{-3.0,  3.0},{-3.0, -3.0},{ 2.0, -3.0},
                { 2.0,  1.0},{ 0.0,  1.0},{ 4.0,  5.0},{ 7.0,  5.0},
                { 5.0,  3.0},{ 7.0,  1.0},{ 7.0, -3.0},{ 5.0, -5.0},
                {-6.0, -5.0},{-8.0, -3.0},
            }
        },
        // Pict:114 "r"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-3.0, -3.0},
                { 2.0, -3.0},{ 2.0,  0.0},{-1.0,  0.0},{-1.0,  2.0},
                { 2.0,  5.0},{ 7.0,  5.0},{ 4.0,  2.0},{ 5.0,  2.0},
                { 7.0,  0.0},{ 7.0, -3.0},{ 5.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:115 "s"
        {
            {
                {-8.0, -3.0},{-8.0, -1.0},{-6.0,  1.0},{ 2.0,  1.0},
                { 2.0,  3.0},{-8.0,  3.0},{-8.0,  5.0},{ 5.0,  5.0},
                { 7.0,  3.0},{ 7.0,  1.0},{ 5.0, -1.0},{-3.0, -1.0},
                {-3.0, -3.0},{ 7.0, -3.0},{ 7.0, -5.0},{-6.0, -5.0},
                {-8.0, -3.0},
            }
        },
        // Pict:116 "t"
        {
            {
                {-8.0, -5.0},{-8.0, -3.0},{-3.0, -3.0},{-3.0,  5.0},
                { 2.0,  5.0},{ 2.0, -3.0},{ 7.0, -3.0},{ 7.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:117 "u"
        {
            {
                {-8.0, -5.0},{-8.0,  3.0},{-6.0,  5.0},{ 5.0,  5.0},
                { 7.0,  3.0},{ 7.0, -5.0},{ 2.0, -5.0},{ 2.0,  3.0},
                {-3.0,  3.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:118 "v"
        {
            {
                {-8.0, -5.0},{-8.0,  0.0},{-3.0,  5.0},{ 2.0,  5.0},
                { 7.0,  0.0},{ 7.0, -5.0},{ 2.0, -5.0},{ 2.0,  0.0},
                { 0.0,  2.0},{-1.0,  2.0},{-3.0,  0.0},{-3.0, -5.0},
                {-8.0, -5.0},
            }
        },
        // Pict:119 "w"
        {
            {
                {-8.0, -5.0},{-8.0,  5.0},{-3.0,  5.0},{-1.0,  3.0},
                { 0.0,  3.0},{ 2.0,  5.0},{ 7.0,  5.0},{ 7.0, -5.0},
                { 2.0, -5.0},{ 2.0,  2.0},{ 0.0,  0.0},{-1.0,  0.0},
                {-3.0,  2.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:120 "x"
        {
            {
                {-8.0, -5.0},{-8.0, -4.0},{-4.0,  0.0},{-8.0,  4.0},
                {-8.0,  5.0},{-3.0,  5.0},{-3.0,  4.0},{-1.0,  2.0},
                { 0.0,  2.0},{ 2.0,  4.0},{ 2.0,  5.0},{ 7.0,  5.0},
                { 7.0,  4.0},{ 3.0,  0.0},{ 7.0, -4.0},{ 7.0, -5.0},
                { 2.0, -5.0},{ 2.0, -4.0},{ 0.0, -2.0},{-1.0, -2.0},
                {-3.0, -4.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:121 "y"
        {
            {
                {-8.0, -5.0},{-8.0, -3.0},{-3.0,  2.0},{-3.0,  5.0},
                { 2.0,  5.0},{ 2.0,  2.0},{ 7.0, -3.0},{ 7.0, -5.0},
                { 2.0, -5.0},{ 2.0, -3.0},{ 0.0, -1.0},{-1.0, -1.0},
                {-3.0, -3.0},{-3.0, -5.0},{-8.0, -5.0},
            }
        },
        // Pict:122 "z"
        {
            {
                {-8.0, -5.0},{-8.0, -3.0},{ 2.0, -3.0},{ 0.0, -1.0},
                {-4.0, -1.0},{-8.0,  3.0},{-8.0,  5.0},{ 7.0,  5.0},
                { 7.0,  3.0},{-3.0,  3.0},{-1.0,  1.0},{ 3.0,  1.0},
                { 7.0, -3.0},{ 7.0, -5.0},{-8.0, -5.0},
            }
        },
    };

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        Color chCol = new Color(0xffffb0);
        int chStyle = Plate.LNFL;

        pNum = new int[cellNum];

        plate = new Plate[cellNum][];
        for(int i=32; i<=122; i++) {
            pNum[i]     = 1;
            plate[i]    = new Plate[pNum[i]];
            plate[i][0] = new Plate(chCol, chStyle, shape[i][0]);
        }
    }

    //========================================================================
    // コンストラクタ
    //========================================================================

    //========================================================================
    // Method
    //========================================================================
    // 画面表示
    public static final void draw(
        int idx,
        Graphics g,       // 表示対象Graphics
        double posx,
        double posy,
        int vec,
        double sc
    ) {
        if(idx != ' ') {
            for(int i=0; i<plate[idx].length; i++) {
                plate[idx][i].draw(g, posx, posy, vec, sc);
            }
        }
    }

    // 画面表示
    public static final void draw(
        int idx,
        Graphics g,       // 表示対象Graphics
        double posx,
        double posy
    ) {
        draw(idx, g, posx, posy, 0, 1.0);
    }

    // 表示色指定画面表示
    public static final void draw(
        int idx,
        Graphics g,       // 表示対象Graphics
        Color col,
        double posx,
        double posy,
        int vec,
        double scX,
        double scY
    ) {
        if(idx != ' ') {
            for(int i=0; i<plate[idx].length; i++) {
                plate[idx][i].draw(g, col, posx, posy, vec, scX, scY);
            }
        }
    }
}

import java.awt.*;

public class Motion {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private double posX;    // 位置ｘ座標
    private double posY;    // 位置ｙ座標
    private double velX;    // 速度ｘ成分
    private double velY;    // 速度ｙ成分
    private int    vecTh;   // 姿勢角
    private int    velTh;   // 回転速度
    private double scale;   // 表示スケール
    private double size;    // 大きさ
    private int    life;    // オブジェクト寿命
    private int    hp;      // オブジェクト耐久度
    private int    count;   // 動作決定用カウンタ
    private int    damage;  // ダメージカウンタ
    private int    behFlag; // 振る舞いフラグ

    //========================================================================
    // コンストラクタ
    //========================================================================
    public Motion(
        double x,       // 位置ｘ座標
        double y,       // 位置ｙ座標
        double velx,    // 速度ｘ成分
        double vely,    // 速度ｙ成分
        int    vecth,   // 方位
        int    velth,   // 回転速度
        double sz,      // 大きさ
        double scale    // 表示スケール
    ) {
        this.posX = x;
        this.posY = y;
        this.velX = velx;
        this.velY = vely;
        this.vecTh = vecth;
        this.velTh = velth;
        this.scale = scale;
        this.size = sz;

        this.life = 0;
        this.hp = 0;
        this.count = 0;
        this.damage = 0;
        this.behFlag = 0;
    }

    public Motion(
        double x,       // 位置ｘ座標
        double y,       // 位置ｙ座標
        double sz       // 大きさ
    ) {
        this(x, y, 0.0, 0.0, 0, 0, sz, 1.0);
    }

    //========================================================================
    // Method
    //========================================================================
    // 画面表示
//    public final void draw(
//        Graphics g,       // 表示対象Graphics
//        Plate p           // 表示Plate
//    ) {
//        for(int i=0; i<p.length; i++) {
//            p[i].calcDisp(posX, posY, vecTh, scale);
//            p[i].draw(g);
//        }
//    }

    // 画面表示
//    public final void draw(
//        Graphics g,       // 表示対象Graphics
//        Plate p,          // 表示Plate
//        double x,         // 表示位置ｘ座標
//        double y,         // 表示位置ｙ座標
//        int th,           // 表示回転角
//        double sc         // 表示スケール
//    ) {
//        for(int i=0; i<p.length; i++) {
//            p[i].calcDisp(x, y, th, sc);
//            p[i].draw(g);
//        }
//    }

    // 色指定付き画面表示
//    public final void draw(
//        Graphics g,     // 表示対象Graphics
//        Plate p,        // 表示Plate
//        Color col       // 指定表示色
//    ) {
//        for(int i=0; i<p.length; i++) {
//            p[i].calcDisp(posX, posY, vecTh, scale);
//            p[i].draw(g, col);
//        }
//    }

    // 移動
    public final void move() {
        posX  += velX;
        posY  += velY;
        vecTh += velTh;
        count++;

        if(vecTh >= 360) {
            vecTh -= 360;
        }
        if(vecTh < 0) {
            vecTh += 360;
        }
    }

    // ベクトル移動
    public final void vecMove() {
        double vel;

        count++;
        vecTh += velTh;
        if(vecTh >= 360) {
            vecTh -= 360;
        }
        if(vecTh < 0) {
            vecTh += 360;
        }

        vel = MyMath.sqrt(velX*velX+velY*velY);
        velX = MyMath.cos(vecTh)*vel;
        velY = MyMath.sin(vecTh)*vel;
        posX += velX;
        posY += velY;
    }

    // 位置補正
    public final void corrPos(
        double scrnX,
        double scrnY
    ) {
        if(posX >= scrnX) {
            posX -= scrnX;
        }
        if(posX < 0.0) {
            posX += scrnX;
        }
        if(posY >= scrnY) {
            posY -= scrnY;
        }
        if(posY < 0.0) {
            posY += scrnY;
        }
    }

    // 姿勢角変更
    public final void rotTh(
        int th          // 変更差分(+:右回り／-:左回り)
    ) {
        vecTh += th;
        if(vecTh >= 360) {
            vecTh -= 360;
        }
        if(vecTh < 0) {
            vecTh += 360;
        }
    }

    // 速度ベクトル設定
    public final void setVec(
        int th,         // 方位ベクトル
        double v        // 速度スカラ量
    ) {
        velX = v * MyMath.cos(th);
        velY = v * MyMath.sin(th);
    }

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

        velX += v * MyMath.cos(th);
        velY += v * MyMath.sin(th);
        vel = velX*velX+velY*velY;

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

    // 一定率加減速
    public final void reduce(
        double rate  // 加減速率
    ) {
        velX *= rate;
        velY *= rate;
    }

    // オブジェクト生死判定
    public final boolean isDead() {
        return !isAlive();
    }

    // オブジェクト生死判定
    public final boolean isAlive() {
        boolean result;
        if((life == 0) || (hp == 0)) {
            result = false;
        } else {
            result = true;
        }
        return result;
    }

    // life設定
    public final void setLife(
        int life_        // life設定値
    ) {
        life = life_;
    }

    // lifeを0に設定
    public final void kill() {
        life = 0;
        hp = 0;
    }

    // life取得
    public final int getLife() {
        return life;
    }

    // life設定値変更
    public final void mdfLife(
        int mdf        // 変化量
    ) {
        life += mdf;
    }

    // lifeデクリメント
    public final void decLife() {
        life--;
    }

    public final int getHp() {
        return hp;
    }

    public final void setHp(
        int hp_
    ) {
        hp = hp_;
    }

    public final void mdfHp(
        int mdf
    ) {
        hp += mdf;
    }

    public final void decHp() {
        hp--;
    }

    public final void setBehFlag(
        int flag
    ) {
        behFlag = flag;
    }

    public final int getBehFlag() {
        return behFlag;
    }

    // カウンタ初期化
    public final void initCount() {
        count = 0;
    }

    // カウンタ増
    public final void incCount() {
        count++;
    }

    // カウンタ取得
    public final int getCount() {
        return count;
    }

    // 位置設定
    public final void setPos(
        double x,       // 位置設定ｘ座標
        double y        // 位置設定ｙ座標
    ) {
        posX = x;
        posY = y;
    }

    // 指定量移動
    public final void offsetPos(
        double dx,
        double dy
    ) {
        posX  += dx;
        posY  += dy;
    }

    // 位置ｘ座標取得
    public final double getPosX() {
        return posX;
    }

    // 位置ｙ座標取得
    public final double getPosY() {
        return posY;
    }

    // サイズ取得
    public final double getSize() {
        return size * scale;
    }

    // スケール変更
    public final void chgScale(
        double v        // 倍率
    ) {
        scale *= v;
    }

    // スケール変更
    public final void setScale(
        double v        // 倍率
    ) {
        scale = v;
    }

    // スケール取得
    public final double getScale() {
        return scale;
    }

    // 位置指定範囲内外判定
    public final boolean isRangeOut(
        double x1,      // 位置判定ｘ座標(左上端)
        double y1,      // 位置判定ｙ座標(左上端)
        double x2,      // 位置判定ｘ座標(右下端)
        double y2       // 位置判定ｙ座標(右下端)
    ) {
        boolean result;

        if((posX < x1) || (posX > x2) || (posY < y1) || (posY > y2)) {
            result = true;
        } else {
            result = false;
        }

        return result;
    }

    // 速度設定
    public final void setVel(
        double vx,      // 設定速度ｘ成分
        double vy       // 設定速度ｙ成分
    ) {
        velX = vx;
        velY = vy;
    }

    // 速度ｘ成分取得
    public final double getVX() {
        return velX;
    }

    // 速度ｙ成分取得
    public final double getVY() {
        return velY;
    }

    // 姿勢角設定
    public final void setVecTh(
        int th          // 設定方位
    ) {
        vecTh = th;
    }

    // 姿勢角設定
    public final void mdfVecTh(
        int th          // 設定方位
    ) {
        vecTh += th;
        if(vecTh >= 360) {
            vecTh -= 360;
        }
        if(vecTh < 0) {
            vecTh += 360;
        }
    }

    // 回転角速度設定
    public final void setVelTh(
        int vel         // 設定回転角速度
    ) {
        velTh = vel;
    }

    // 姿勢角取得
    public final int getVecTh() {
        return vecTh;
    }

    // 回転角速度取得
    public final int getVelTh() {
        return velTh;
    }

    public final void setDamage(
        int dam
    ) {
        damage = dam;
    }

    public final void decDamage() {
        damage--;
    }

    public final int getDamage() {
        return damage;
    }

    public final boolean isDamaged() {
        boolean result;

        if(damage != 0) {
            result = true;
        } else {
            result = false;
        }

        return result;
    }
}

import java.awt.*;

public class Own extends Motion {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static final double size = 3.0;            // サイズ
    private static final int pNum = 3;                 // 構成Plate数
    private static Plate plate[];                      // 構成Plate配列
    private static final Color colorC = new Color(0xd0d0d0);  // 表示色(Body)
    private static final int styleC = Plate.LNFL;             // 表示スタイル(Body)
    static final double shapeC[][] = {                 // 形状(Body)
        {  0.0, -15.0},
        {  3.0,   3.0},
        { -3.0,   3.0},
        {  0.0, -15.0}
    };
    private static final Color colorR = new Color(0x9090c0);  // 表示色(Rwing)
    private static final int styleR = Plate.LNFL;             // 表示スタイル(Rwing)
    static final double shapeR[][] = {                 // 形状(Rwing)
        {  3.0,  -6.0},
        { 12.0,   8.0},
        {  6.0,   6.0},
        {  3.0,  -6.0}
    };
    private static final Color colorL = new Color(0x9090c0);  // 表示色(Lwing)
    private static final int styleL = Plate.LNFL;             // 表示スタイル(Lwing)
    static final double shapeL[][] = {                 // 形状(Lwing)
        { -3.0,  -6.0},
        {-12.0,   8.0},
        { -6.0,   6.0},
        { -3.0,  -6.0}
    };

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        plate = new Plate[pNum];
        plate[0] = new Plate(colorC, styleC, shapeC);
        plate[1] = new Plate(colorL, styleL, shapeL);
        plate[2] = new Plate(colorR, styleR, shapeR);
    }

    //========================================================================
    // コンストラクタ
    //========================================================================
    Own(double x, double y) {
        super(x, y, size);
    }

    //========================================================================
    // Method
    //========================================================================
    // 画面表示
    public final void draw(
        Graphics g        // 表示対象Graphics
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 表示色指定画面表示
    public final void draw(
        Graphics g,      // 表示対象Graphics
        Color    col     // 表示色
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, col, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }
}

import java.awt.*;

public class Blast extends Motion {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static final int num = 64;                 // 総数
    private static final int life = 20;                // 寿命
    private static final int hp = -1;                  // 耐久度
    private static final double size = 4.0;            // サイズ
    private static final int pNum = 1;                 // 構成Plate数
    private static Plate plate[];                      // 構成Plate配列
    private static final Color color = new Color(0xffa060);  // 表示色(Body)
    private static final int style = Plate.LNFL;             // 表示スタイル(Body)
    static final double shape[][] = {                        // 形状(Body)
        {  -2.0, -3.0},
        {   2.0,  0.0},
        {  -2.0,  3.0},
        {  -2.0, -3.0}
//        {  -4.0, -6.0},
//        {   4.0,  0.0},
//        {  -4.0,  6.0},
//        {  -4.0, -6.0}
    };

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        plate = new Plate[pNum];
        plate[0] = new Plate(color, style, shape);
    }

    //========================================================================
    // コンストラクタ
    //========================================================================
    Blast() {
        super(0.0, 0.0, size);
    }

    //========================================================================
    // Method
    //========================================================================
    // 総数取得
    static public int getNum() {
        return num;
    }

    // 表示色指定画面表示
    public final void draw(
        Graphics g       // 表示対象Graphics
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 初期化処理
    public void init(
        double posx,
        double posy,
        int vecth,
        int velth,
        double vx,
        double vy,
        int thr,
        double thrV,
        double thrVL
    ) {
        setLife(life);
        setHp(hp);
        setPos(posx, posy);
        setVelTh(velth);
        setVecTh(vecth);
        setVel(vx, vy);
        thrust(thr, thrV, thrVL);
    }
}

import java.awt.*;

public class Bullet extends Enemy {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static final int num = 96;                 // 総数
    private static final int life = 360;               // 寿命
    private static final int hp = -1;                  // 耐久度
    private static final double size = 3.0;            // サイズ

    private static final int power = 12;               // 威力

    private static final int pNum = 1;                 // 構成Plate数
    private static Plate plate[];                      // 構成Plate配列
    private static final Color color = new Color(0xffffd0);  // 表示色(Body)
    private static final int style = Plate.LINE;             // 表示スタイル(Body)
    static final double shape[][] = {                        // 形状(Body)
        { -3.0, 0.0},
        {  3.0, 0.0},
    };

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        plate = new Plate[pNum];
        plate[0] = new Plate(color, style, shape);

        setPow(power);
    }

    //========================================================================
    // コンストラクタ
    //========================================================================
    Bullet() {
        super(0.0, 0.0, size);
    }

    //========================================================================
    // Method
    //========================================================================
    // 総数取得
    static public int getNum() {
        return num;
    }

    // 画面表示
    public final void draw(
        Graphics g        // 表示対象Graphics
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 初期化処理
    public void init(double posx, double posy, int vec) {
        setPos(posx, posy);
        setLife(life);
        setHp(hp);
        setVelTh(0);
        setVecTh(vec);
        setVec(vec, 2.0);
        setScale(1.0);
    }
}

public class Enemy extends Motion {
    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static int points;
    private static int power;

    //========================================================================
    // コンストラクタ
    //========================================================================
    Enemy(double posx, double posy, double size) {
        super(posx, posy, size);
    }

    //========================================================================
    // Method
    //========================================================================
    // 得点設定
    public static void setPts(int pts) {
        points = pts;
    }

    // 得点取得
    public static int getPts() {
        return points;
    }

    // 威力取得
    static public void setPow(int pow) {
        power = pow;
    }

    // 威力取得
    static public int getPow() {
        return power;
    }
}

import java.awt.*;

public class EnemA extends Enemy {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static final int num = 16;                      // 総数
    private static final int life = 400;                    // 寿命
    private static final int hp = 2;                        // 耐久度
    private static final double size = 5.0;                 // サイズ

    private static final int power = 16;                // 威力

    private static Plate plate[];                           // 構成Plate配列
    private static final int pNum = 3;                      // 構成Plate数

    private static final Color colorC = new Color(0xd0d0ff); // 表示色
    private static final int styleC = Plate.LNFL;            // 表示スタイル
    private static final double shapeC[][] = {               // 形状
        {  2.0, 2.0},
        {  8.0, 0.0},
        {  2.0,-2.0},
        {  2.0, 2.0},
    };
    private static final Color colorL = new Color(0xa0a0ff); // 表示色
    private static final int styleL = Plate.LNFL;            // 表示スタイル
    private static final double shapeL[][] = {               // 形状
        { -4.0, 8.0},
        {  6.0, 3.0},
        {  0.0, 3.0},
        { -4.0, 8.0},
    };
    private static final Color colorR = new Color(0xa0a0ff); // 表示色
    private static final int styleR = Plate.LNFL;            // 表示スタイル
    private static final double shapeR[][] = {               // 形状
        { -4.0, -8.0},
        {  6.0, -3.0},
        {  0.0, -3.0},
        { -4.0, -8.0},
    };

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        plate = new Plate[pNum];
        plate[0] = new Plate(colorC, styleC, shapeC);
        plate[1] = new Plate(colorR, styleR, shapeR);
        plate[2] = new Plate(colorL, styleL, shapeL);

        setPts(16);
        setPow(8);
    }

    //========================================================================
    // コンストラクタ
    //========================================================================
    EnemA() {
        super(0.0, 0.0, size);
    }

    //========================================================================
    // Method
    //========================================================================
    // 総数取得
    static public int getNum() {
        return num;
    }

    // 画面表示
    public final void draw(
        Graphics g        // 表示対象Graphics
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 表示色指定画面表示
    public final void draw(
        Graphics g,      // 表示対象Graphics
        Color    col     // 表示色
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, col, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 初期化処理
    public final void init(double posx, double posy, int flag) {
        setPos(posx, posy);
        setVecTh(90);
        setVelTh(0);
        setVec(90, 3.0);
        setLife(life);
        setHp(hp);
        setDamage(0);
        initCount();
        setScale(1.0);
        setBehFlag(flag);
    }
}

import java.awt.*;

public class EnemB extends Enemy {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static final int num = 16;                      // 総数
    private static final int life = 300;                    // 寿命
    private static final int hp = 1;                        // 耐久度
    private static final double size = 6.0;                 // サイズ

    private static final int power = 16;                     // 威力

    private static Plate plate[];                           // 構成Plate配列
    private static final int pNum = 3;                      // 構成Plate数

    private static final Color colorC = new Color(0xffff80); // 表示色
    private static final int styleC = Plate.LNFL;            // 表示スタイル
    private static final double shapeC[][] = {               // 形状
        {  1.0, -3.0},
        {  7.0,  0.0},
        {  1.0,  3.0},
        {  1.0, -3.0},
    };
    private static final Color colorR = new Color(0xd0d0d0); // 表示色
    private static final int styleR = Plate.LNFL;            // 表示スタイル
    private static final double shapeR[][] = {               // 形状
        { -3.0,  8.0},
        { -5.0,  4.0},
        {  5.0,  4.0},
        {  4.0,  6.0},
        { -3.0,  8.0},
    };
    private static final Color colorL = new Color(0xd0d0d0); // 表示色
    private static final int styleL = Plate.LNFL;            // 表示スタイル
    private static final double shapeL[][] = {               // 形状
        { -3.0,  -8.0},
        { -5.0,  -4.0},
        {  5.0,  -4.0},
        {  4.0,  -6.0},
        { -3.0,  -8.0},
    };

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        plate = new Plate[pNum];
        plate[0] = new Plate(colorC, styleC, shapeC);
        plate[1] = new Plate(colorR, styleR, shapeR);
        plate[2] = new Plate(colorL, styleL, shapeL);

        setPts(24);
        setPow(power);
    }

    //========================================================================
    // コンストラクタ
    //========================================================================
    EnemB() {
        super(0.0, 0.0, size);
    }

    //========================================================================
    // Method
    //========================================================================
    // 総数取得
    static public int getNum() {
        return num;
    }

    // 画面表示
    public final void draw(
        Graphics g        // 表示対象Graphics
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 表示色指定画面表示
    public final void draw(
        Graphics g,      // 表示対象Graphics
        Color    col     // 表示色
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, col, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 初期化
    public final void init(double posx, double posy) {
        setPos(posx, posy);
        setVecTh(90);
        setVelTh(0);
        setVel(0, 3.0);
        setLife(life);
        setDamage(0);
        setHp(hp);
        initCount();
        setScale(1.0);
    }
}

import java.awt.*;

public class EnemC extends Enemy {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static final int num = 12;                       // 総数
    private static final int life = 360;                     // 寿命
    private static final int hp = 16;                        // 耐久度
    private static final double size = 11.0;                 // サイズ

    private static final int power = 32;                // 威力

    private static Plate plate[];                            // 構成Plate配列
    private static final int pNum = 1;                       // 構成Plate数

    private static final Color color1 = new Color(0xa0a0a0); // 表示色
    private static final int style1 = Plate.LNFL;            // 表示スタイル
    private static final double shape1[][] = {               // 形状
        { -12.0,  -8.0},
        {  -8.0, -12.0},
        {   8.0, -12.0},
        {  12.0,  -8.0},
        {  12.0,   8.0},
        {   8.0,  12.0},
        {  -8.0,  12.0},
        { -12.0,   8.0},
        { -12.0,  -8.0},
    };

    private static final Color color2 = new Color(0xa0a0a0); // 表示色
    private static final int style2 = Plate.LNFL;            // 表示スタイル
    private static final double shape2[][] = {               // 形状
        { -10.0,  -6.0},
        {  -6.0, -10.0},
        {   6.0, -10.0},
        {  10.0,  -6.0},
        {  10.0,   6.0},
        {   6.0,  10.0},
        {  -6.0,  10.0},
        { -10.0,   6.0},
        { -10.0,  -6.0},
    };

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        plate = new Plate[pNum];
        plate[0] = new Plate(color1, style1, shape1);
//        plate[1] = new Plate(color2, style2, shape2);

        setPts(32);
        setPow(power);
    }

    //========================================================================
    // コンストラクタ
    //========================================================================
    EnemC() {
        super(0.0, 0.0, size);
    }

    //========================================================================
    // Method
    //========================================================================
    // 総数取得
    static public int getNum() {
        return num;
    }

    // 画面表示
    public final void draw(
        Graphics g        // 表示対象Graphics
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 表示色指定画面表示
    public final void draw(
        Graphics g,      // 表示対象Graphics
        Color    col     // 表示色
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, col, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    public final void init(
        double posx,
        double posy,
        double vx,
        double vy
    ) {
        setPos(posx, posy);
        setVecTh(0);
        setVelTh(2);
        setVel(vx, vy);
        setLife(life);
        setHp(hp);
        setDamage(0);
        initCount();
        setScale(1.0);
    }
}

import java.awt.*;

public class EnemD extends Enemy {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static final int num = 8;                        // 総数
    private static final int life = 400;                     // 寿命
    private static final int hp = 4;                         // 耐久度
    private static final double size = 11.0;                 // サイズ

    private static final int power = 24;                // 威力

    private static final int pNum = 5;                       // 構成Plate数
    private static Plate plate[];                            // 構成Plate配列

    private static final Color color1 = new Color(0xf0f0b0); // 表示色
    private static final int style1 = Plate.LNFL;            // 表示スタイル
    private static final double shape1[][] = {               // 形状
        {  1.0, 10.0},
        {  1.0,  1.0},
        { 10.0,  1.0},
        {  1.0, 10.0},
    };
    private static final Color color2 = new Color(0xf0f0b0); // 表示色
    private static final int style2 = Plate.LNFL;            // 表示スタイル
    private static final double shape2[][] = {               // 形状
        {  1.0, -10.0},
        {  1.0,  -1.0},
        { 10.0,  -1.0},
        {  1.0, -10.0},
    };
    private static final Color color3 = new Color(0xf0f0b0); // 表示色
    private static final int style3 = Plate.LNFL;            // 表示スタイル
    private static final double shape3[][] = {               // 形状
        {  -1.0, 10.0},
        {  -1.0,  1.0},
        { -10.0,  1.0},
        {  -1.0, 10.0},
    };
    private static final Color color4 = new Color(0xf0f0b0); // 表示色
    private static final int style4 = Plate.LNFL;            // 表示スタイル
    private static final double shape4[][] = {               // 形状
        {  -1.0, -10.0},
        {  -1.0,  -1.0},
        { -10.0,  -1.0},
        {  -1.0, -10.0},
    };
    private static final Color color5 = new Color(0xff4040); // 表示色
    private static final int style5 = Plate.FILL;            // 表示スタイル
    private static final double shape5[][] = {               // 形状
        { -5.0, -5.0},
        {  5.0, -5.0},
        {  5.0,  5.0},
        { -5.0,  5.0},
        { -5.0, -5.0},
//        { -6.0, -4.0},
//        { -4.0, -6.0},
//        {  4.0, -6.0},
//        {  6.0, -4.0},
//        {  6.0,  4.0},
//        {  4.0,  6.0},
//        { -4.0,  6.0},
//        { -6.0,  4.0},
//        { -6.0, -4.0},
    };

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        plate = new Plate[pNum];
        plate[0] = new Plate(color5, style5, shape5);
        plate[1] = new Plate(color1, style1, shape1);
        plate[2] = new Plate(color2, style2, shape2);
        plate[3] = new Plate(color3, style3, shape3);
        plate[4] = new Plate(color4, style4, shape4);

        setPts(24);
        setPow(power);
    }

    //========================================================================
    // コンストラクタ
    //========================================================================
    EnemD() {
        super(0.0, 0.0, size);
    }

    //========================================================================
    // Method
    //========================================================================
    // 総数取得
    static public int getNum() {
        return num;
    }

    // 画面表示
    public final void draw(
        Graphics g        // 表示対象Graphics
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 表示色指定画面表示
    public final void draw(
        Graphics g,      // 表示対象Graphics
        Color    col     // 表示色
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, col, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 初期化処理
    public final void init(double posx, double posy) {
        setPos(posx, posy);
        setVecTh(0);
        setVelTh(2);
        setVel(0.0, 1.5);
        setLife(life);
        setHp(hp);
        setDamage(0);
        initCount();
        setScale(1.0);
    }
}

import java.awt.*;

public class Zapper extends Motion {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static final int num = 16;                 // 総数
    private static final int life = 128;               // 寿命
    private static final int hp = -1;                  // 耐久度
    private static final double size = 3.0;            // サイズ
    private static final int pNum = 1;                 // 構成Plate数
    private static Plate plate[];                      // 構成Plate配列
    private static final Color color = new Color(0xffff00);  // 表示色(Body)
    private static final int style = Plate.LINE;             // 表示スタイル(Body)
    static final double shape[][] = {                        // 形状(Body)
        { -0.5,  -4.0},
        {  0.5,  -4.0},
        {  0.5,   2.0},
        { -0.5,   2.0},
        { -0.5,  -4.0}
    };

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        plate = new Plate[pNum];
        plate[0] = new Plate(color, style, shape);
    }

    //========================================================================
    // コンストラクタ
    //========================================================================
    Zapper() {
        super(0.0, 0.0, size);
    }

    //========================================================================
    // Method
    //========================================================================
    // 総数取得
    static public int getNum() {
        return num;
    }

    // 画面表示
    public final void draw(
        Graphics g        // 表示対象Graphics
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 初期化処理
    public void init(double posx, double posy, int vecth, int vec) {
        setLife(life);
        setHp(hp);
        setPos(posx, posy);
        setVelTh(0);
        setVecTh(vecth);
        setVec(vec, 6.0);
    }
}

import java.awt.*;

public class Spark extends Motion {

    //========================================================================
    // インスタンス変数定義
    //========================================================================
    private static final int num = 96;                 // 総数
    private static final int life = 16;                // 寿命
    private static final int hp = -1;                  // 耐久度
    private static final double size = 2.0;            // サイズ
    private static final int pNum = 1;                 // 構成Plate数
    private static Plate plate[];                      // 構成Plate配列
    private static final Color color = new Color(0xffffc0);  // 表示色(Body)
    private static final int style = Plate.LINE;             // 表示スタイル(Body)
    static final double shape[][] = {                        // 形状(Body)
        {  0.0,  -1.0},
        {  0.0,   1.0},
    };

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        plate = new Plate[pNum];
        plate[0] = new Plate(color, style, shape);
    }

    //========================================================================
    // コンストラクタ
    //========================================================================
    Spark() {
        super(0.0, 0.0, size);
    }

    //========================================================================
    // Method
    //========================================================================
    // 総数取得
    static public int getNum() {
        return num;
    }

    // 表示色指定画面表示
    public final void draw(
        Graphics g,      // 表示対象Graphics
        Color    col     // 表示色
    ) {
        for(int i=0; i<plate.length; i++) {
            plate[i].draw(g, col, getPosX(), getPosY(), getVecTh(), getScale());
        }
    }

    // 初期化処理
    public void init(
        double posx,
        double posy,
        int vecth,
        int velth,
        double vx,
        double vy,
        int thr,
        double thrV,
        double thrVL
    ) {
        setLife(life);
        setHp(hp);
        setPos(posx, posy);
        setVelTh(velth);
        setVecTh(vecth);
        setVel(vx, vy);
        thrust(thr, thrV, thrVL);
    }
}

public final class Map
{
    static private final int mapSizeX = 16;
    static private final int mapNum = 1;
    static private final String mapStr[][] =
    {
      // "0123456789abcdef"
       {
         "................",
         "................",
         ".....B..........",
         ".....B..........",
         ".....B..........",
         ".....B..........",
         "................",
         "................",
         "..........B.....",
         "..........B.....",
         "..........B.....",
         "..........B.....",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "AA............AA",
         "AA............AA",
         "AA............AA",
         "AA............AA",
         "................",
         "................",
         "................",
         "................",
         "................",
         "D..............D",
         "D..............D",
         "D..............D",
         "D..............D",
         "................",
         "................",
         "................",
         "................",
         "..B..........B..",
         "...B........B...",
         "....B......B....",
         ".....B....B.....",
         "......B..B......",
         "................",
         "AA............AA",
         "AA............AA",
         "AA............AA",
         "AA............AA",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         ".....C..........",
         "................",
         ".......BB.......",
         "......B..B.....C",
         ".....B...CB.....",
         "....B......B....",
         "..............C.",
         ".C..............",
         "................",
         ".....C..........",
         "...........C....",
         "................",
         "...C............",
         ".............C..",
         "................",
         ".......BB.......",
         "......B..B......",
         "C....B....B.....",
         "....B......B....",
         "................",
         ".............C..",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "A..............A",
         "A..............A",
         ".A............A.",
         ".A............A.",
         "..A..........A..",
         "..A..........A..",
         "...A........A...",
         "...A........A...",
         "................",
         "................",
         ".....D....D.....",
         ".....D....D.....",
         ".....D....D.....",
         ".....D....D.....",
         ".......BB.......",
         "......B..B......",
         ".....B....B.....",
         "....B......B....",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "A..............A",
         "A..............A",
         ".A............A.",
         ".A............A.",
         "..A..........A..",
         "..A..........A..",
         "...A........A...",
         "...A........A...",
         "................",
         "................",
         ".......BB.......",
         "......B..B......",
         ".....B....B.....",
         "....B..BB..B....",
         "...B..B..B..B...",
         ".....B....B.....",
         "....B......B....",
         "...B........B...",
         "................",
         "................",
         "A..............A",
         "A..............A",
         "AD............DA",
         "AD............DA",
         ".D............D.",
         ".D............D.",
         "A..............A",
         "A..............A",
         "A..............A",
         "A..............A",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "........C.......",
         "............C...",
         "...C............",
         "..............C.",
         ".......C........",
         "..C.......C.....",
         "....C.........C.",
         "........C.......",
         "...C............",
         ".............C..",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         "................",
         ".......BB.......",
         "......B..B......",
         ".....B....B.....",
         "....B..BB..B....",
         "...B..B..B..B...",
         ".....B....B.....",
         "....B......B....",
         "...B........B...",
         "A..............A",
         "A..............A",
         ".A............A.",
         ".A............A.",
         "..A..........A..",
         "..A..........A..",
         "...A........A...",
         "...A........A...",
         ".......BB.......",
         "......B..B......",
         ".....B....B.....",
         "....B..BB..B....",
         "...B..B..B..B...",
         ".....B....B.....",
         "....B......B....",
         "...B........B...",
         "................",
         "A..............A",
         "A..............A",
         "A..............A",
         "A..............A",
         "................",
         "................",
       }
    };

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

    // データ数取得
    ///////////////////////////////////////////////////////////////////////////
    public static final int getMapNum()
    {
        return mapNum;
    }

    // マップ・データのサイズ取得
    ///////////////////////////////////////////////////////////////////////////
    public static final int getMapSizeY(
        int lev         // level
    ) {
        return mapStr[lev].length;
    }

    public static final int getMapSizeX()
    {
        return mapSizeX;
    }

    // マップ・データを取得
    ///////////////////////////////////////////////////////////////////////////
    public static final char getMap(int level, int x, int y)
    {
        String str = mapStr[level][y];
        char   ch  = str.charAt(x);
        return ch;
    }
}

//============================================================================
//  数学計算Class
//============================================================================
//  method:
//  ■テーブル初期化
//      public static final void init();
//
//  ■sin関数値返却
//      public static final double sin(int deg);
//
//  ■cos関数値返却
//      public static final double cos(int deg);
//
//  ■２点間方位返却
//      public static final int getBrg(double x1, double y1,
//                                     double x2, double y2)
//
//============================================================================
import java.lang.*;

final public class MyMath {

    //========================================================================
    // 三角関数テーブル
    //========================================================================
    private static double sinTbl[];
    private static double cosTbl[];
    private static int atanTbl[];

    //========================================================================
    // 定数定義
    //========================================================================
    static final double D2R = Math.PI / 180.0;  // Degree/Radian変換係数
    static final int    DEG = 360;
    static final int    ATAN = 100;             // atan2の精度

    //========================================================================
    // 静的初期化
    //========================================================================
    static {
        sinTbl  = new double[DEG];
        cosTbl  = new double[DEG];
        atanTbl = new int[ATAN];
        for(int deg=0; deg<DEG; deg++) {
            sinTbl[deg] = Math.sin((double)deg * D2R);
            cosTbl[deg] = Math.cos((double)deg * D2R);
        }
        for(int at=0; at<ATAN; at++) {
            atanTbl[at] = (int)(Math.atan((double)at * 0.01) / D2R);
        }
    }

    //========================================================================
    // sin関数
    //========================================================================
    public static final double sin(
        int deg         // 入力値[degree]
    ) {
        return sinTbl[regDeg(deg)];
    }

    //========================================================================
    // cos関数
    //========================================================================
    public static final double cos(
        int deg         // 入力値[degree]
    ) {
        return cosTbl[regDeg(deg)];
    }

    //========================================================================
    // DEGREE単位系正規化
    //========================================================================
    public static final int regDeg(
        int deg
    ) {
        int result;

        while(deg >= DEG) {
            deg -= DEG;
        }
        while(deg < 0) {
            deg += DEG;
        }

        result = deg;

        return result;
    }

    //========================================================================
    // sqrt関数
    //========================================================================
    public static final double sqrt(
        double num      // 入力値
    ) {
        return Math.sqrt(num);
    }

    //========================================================================
    // 整数乱数関数
    //========================================================================
    public static final int iRnd(int range) {
        return (int)(Math.random()*range);
    }

    //========================================================================
    // 実数乱数関数
    //========================================================================
    public static final double fRnd(double range) {
        return Math.random()*range;
    }

    //========================================================================
    // ２点間方位取得
    //========================================================================
    public static final int getBrg(
        double x1,
        double y1,
        double x2,
        double y2
    ) {
        double dx, dy;
        int result = 0;
        int at;
        int deg0;
        boolean rvs;

        dx = x2 - x1;
        dy = y2 - y1;

        // 第１象限
        if((dx >= 0) && (dy >= 0)) {
            if(Math.abs(dy) > Math.abs(dx)) {
                at = (int)((dx / dy) * 100) - 1;
                if(at < 0) {
                    at = 0;
                }
if((at < 0) || (at >= 100)) {
System.out.println("at:"+at+",x1:"+x1+",y1:"+y1+",x2:"+x2+",y2:"+y2);
}
                deg0 = regDeg(atanTbl[at]);
                result = 89 - deg0;
            } else {
                at = (int)((dy / dx) * 100) - 1;
                if(at < 0) {
                    at = 0;
                }
if((at < 0) || (at >= 100)) {
System.out.println("at:"+at+",x1:"+x1+",y1:"+y1+",x2:"+x2+",y2:"+y2);
}
                deg0 = regDeg(atanTbl[at]);
                result = deg0;
            }
        }
        // 第２象限
        if((dx < 0) && (dy >= 0)) {
            if(Math.abs(dy) > Math.abs(dx)) {
                at = (int)((-dx / dy) * 100) - 1;
                if(at < 0) {
                    at = 0;
                }
if((at < 0) || (at >= 100)) {
System.out.println("at:"+at+",x1:"+x1+",y1:"+y1+",x2:"+x2+",y2:"+y2);
}
                deg0 = regDeg(atanTbl[at]);
                result = 90 + deg0;
            } else {
                at = (int)((dy / -dx) * 100) - 1;
                if(at < 0) {
                    at = 0;
                }
if((at < 0) || (at >= 100)) {
System.out.println("at:"+at+",x1:"+x1+",y1:"+y1+",x2:"+x2+",y2:"+y2);
}
                deg0 = regDeg(atanTbl[at]);
                result = 179 - deg0;
            }
        }
        // 第３象限
        if((dx < 0) && (dy < 0)) {
            if(Math.abs(dy) > Math.abs(dx)) {
                at = (int)((-dx / -dy) * 100) - 1;
                if(at < 0) {
                    at = 0;
                }
if((at < 0) || (at >= 100)) {
System.out.println("at:"+at+",x1:"+x1+",y1:"+y1+",x2:"+x2+",y2:"+y2);
}
                deg0 = regDeg(atanTbl[at]);
                result = 269 - deg0;
            } else {
                at = (int)((-dy / -dx) * 100) - 1;
                if(at < 0) {
                    at = 0;
                }
if((at < 0) || (at >= 100)) {
System.out.println("at:"+at+",x1:"+x1+",y1:"+y1+",x2:"+x2+",y2:"+y2);
}
                deg0 = regDeg(atanTbl[at]);
                result = 180 + deg0;
            }
        }
        // 第４象限
        if((dx >= 0) && (dy < 0)) {
            if(Math.abs(dy) > Math.abs(dx)) {
                at = (int)((dx / -dy) * 100) - 1;
                if(at < 0) {
                    at = 0;
                }
if((at < 0) || (at >= 100)) {
System.out.println("at:"+at+",x1:"+x1+",y1:"+y1+",x2:"+x2+",y2:"+y2);
}
                deg0 = regDeg(atanTbl[at]);
                result = 270 + deg0;
            } else {
                at = (int)((-dy / dx) * 100) - 1;
                if(at < 0) {
                    at = 0;
                }
if((at < 0) || (at >= 100)) {
System.out.println("at:"+at+",x1:"+x1+",y1:"+y1+",x2:"+x2+",y2:"+y2);
}
                deg0 = regDeg(atanTbl[at]);
                result = 359 - deg0;
            }
        }

        return result;
    }

}