#apply
#include "../_include.txt"
#include "../../define/_vector2.txt"


cev[CEV_STAFFROLL] .name("mg_スタッフロール") {

    //クレジットデータ
    //待ち時間(f), 位置(0:左寄せ, 1:中央, 2:右寄せ), 文字内容(r:ランダム s:スコア表示 i:アイテム)
    def STR_CREDIT = "
4,0,
3,1,＜スタッフロール＞
2,0,＜ディレクター＞
4,1,r
2,0,＜アートディレクター＞
2,1,r
4,1,i
2,0,＜チーフプログラマ＞
6,0,r
2,0,＜テキストプランナ＞
2,2,r
4,2,r
2,0,＜デザイナー＞
2,1,r
2,1,r
2,1,r
6,1,r
2,0,＜効果音＞
2,2,r
2,2,r
6,2,r
2,0,＜作曲＞
2,0,r
4,0,r
2,0,＜レベルデザイン＞
2,1,r
2,2,r
2,0,r
2,1,r
2,2,r
6,1,i
2,0,＜マップデザイン＞
2,2,r
6,2,r
2,0,＜アドバイザー＞
2,2,r
6,2,r
2,0,＜マネージャー＞
2,0,r
6,2,r
2,0,＜プロデューサー＞
10,1,r
1,1,◆◆◆◆◆◆◆◆◆◆◆
2,0,＜スペシャルサンクス＞
1,0,r
1,0,r
1,0,r
1,0,r
1,2,r
1,2,r
1,2,r
1,2,r
1,0,r
1,0,r
1,0,r
1,0,r
1,2,r
1,2,r
1,2,r
1,2,r
10,1,i
1,1,◆◆◆◆◆◆◆◆◆◆◆
2,0,＜デバッガー＞
1,1,r
1,1,r
2,1,r
1,1,r
1,1,r
2,1,r
1,1,r
1,1,r
10,1,r
1,1,◆◆◆◆◆◆◆◆◆◆◆
2,0,＜クラファン支援者＞
1,0,r
1,0,r
1,1,r
1,1,r
1,0,r
1,0,r
1,2,r
1,2,r
1,2,r
1,2,r
1,0,r
1,0,r
1,0,r
1,0,r
1,1,r
1,1,r
1,1,r
1,1,r
1,2,r
1,2,r
1,2,r
1,2,r
1,0,r
1,1,r
1,2,r
1,2,r
1,2,r
1,1,r
1,0,r
1,0,r
1,1,r
1,1,r
1,2,r
1,2,r
1,1,r
1,1,r
1,0,r
1,1,r
1,2,r
1,1,r
1,0,r
1,1,r
1,2,r
1,0,r
1,1,r
1,2,r
1,1,r
1,2,r
1,1,r
1,2,r
1,0,r
1,1,r
1,2,r
1,0,r
1,1,r
1,2,r
1,0,r
1,1,r
1,2,r
2,1,r
18,0,（順不同）
1,1,◆◆◆◆◆◆◆◆◆◆◆
1,1,プレイありがとう！
1,1,s
1,1,◆◆◆◆◆◆◆◆◆◆◆
25,0,
"
//～$p～
    def {
        NUM_OF_VAR = 420
        NUM_OF_STR = 64
        NUM_OF_PIC = 80

        BASE_LAYER = 6

        PATH_BACK  = "cm\da"

        PIC_HEAD   = 1
        PIC_BACK   = 2
        PIC_AUTO   = 3
        PIC_PLAYER = 4
        PIC_ITEM   = 5
        PIC_TARGET = 6//+0_+47
        PIC_BULLET = 55//+0_+11
        PIC_EXPLO  = 70//+0_+7

        //定数
        OUT_RANGE = -320
        REF_X = WINDOW_WIDTH - STAGE_WIDTH
        REF_Y = 0
        STAGE_WIDTH  = 144
        STAGE_HEIGHT = 240
        UNIT_POS = 100
        UNIT_ANG = 10

        //名前
        FIRST_NAME_LIST = ["アレックス", "役満", "ヨーゼフ", "ほっしゅ",
        "ファルコン", "しみったれ", "ちんぶら", "黄金の",
        "リリア", "しんだ", "ダーク", "フライパン",
        "大和魂の", "スターライト", "塩沢", "めでてぇ",
        "紅の", "冷たい", "うんこ", "ＸＰ",
        "ＵＮＩＴＹ", "シェイド", "マクド", "キリヅマ",
        "山田", "藤沢", "宇宙一", "赤木",
        "幕田", "弟子", "唯一", "勇魚",
        "恍惚なる", "偽", "カナエール", "もりんふぇん",
        "コテハン", "サラーミ", "牛丼", "甘納豆",
        "マッスル", "キャロル", "よしおか", "魔"]
        LAST_NAME_LIST  = ["勝也", "バリア", "Ⅲ", "支配者",
        "漁船", "ハウス", "ファイア", "ブリザード",
        "スパーク", "ナス", "アワビ", "ドラゴン",
        "娘", "レジェント", "ＷＯＲＬＤ", "神",
        "きつね", "たぬき", "アレサ", "スレイヤー",
        "皇女", "アルパカ", "ショウ", "メリッサ",
        "グロリア", "ゴメス", "賢治", "五郎",
        "スミス", "アーマー", "グレル", "スケルトン",
        "幸一郎", "ちんちん", "だっつーの", "駿",
        "パスタ", "けつ子", "鳴門", "ライオン",
        "餓狼", "けるる", "ポテチ", "魔王"]

        FIRST_NAME_SIZE = 4 * 11
        LAST_NAME_SIZE  = 4 * 11

        //プレイヤー
        PL_SPEED = 200
        PL_RAD = 600
        PL_INTERVAL = UNIT_FPS * 3
        PL_MAX_LEVEL = 2

        //アイテム
        IT_STRING = "～$p～"
        IT_ST_NONE = 0
        IT_ST_DELETE
        IT_ST_ENABLE

        IT_SPEED = 40
        IT_RAD = 600

        //自弾
        BU_SPEED = 900
        BU_ATK = 3
        MAX_BU = 6

        BU_ST_NONE = 0
        BU_ST_DELETE
        BU_ST_CREATE
        BU_ST_ENABLE

        MB_STATE = 0
        MB_ANGLE
        MB_X
        MB_Y
        SIZE_OF_BU

        //的
        TAG_DELAY = 25
        TAG_SPEED = 50
        MAX_TAG = 48

        TAG_ST_NONE = 0
        TAG_ST_DELETE
        TAG_ST_CREATE
        TAG_ST_DEFEAT
        TAG_ST_ENABLE

        MT_STATE = 0
        MT_ANGLE
        MT_HP
        MT_DAMAGE
        MT_X
        MT_Y
        SIZE_OF_TAG

        //爆発
        MAX_EX = 8
    }

    def {
        basePicCmd = {
            .chromakey(1)
            .mapLayer(BASE_LAYER)
            .eraseWhenTransfer
            .affectedByTint
            .affectedByFlash
            .affectedByShake
        }

        baseStrPicCmd = {
            .size(0, 0)
            .font("", 12)
            .spacing(0, 4)
            .skin "" .nobg .noframe .noPadding
            basePicCmd
            .affectedByTint
            .affectedByFlash
            .affectedByShake
        }
    }

    //変数定義
    defv {
        varHead = TV_MINIGAME

        ipt
        ang
        lenA
        lenB
        pos
        pidA
        pidB
        iA
        iB
        pA
        pB
        psA
        psB
        fA
        fB
        ax
        ay
        bx
        by
        cx
        cy

        stageDelay
        score
        exploCount

        plTimer
        plLevel
        plAtkIpt
        plAutoIpt
        plAutoMode
        plX
        plY

        itState
        itTimer
        itX
        itY

        buHead
        tagHead = __id(buHead) + MAX_BU * SIZE_OF_BU

        varFoot = __id(tagHead) + MAX_TAG * SIZE_OF_TAG
    }

    deft {
        strQueue = TS_MINIGAME
        strLine
        strParam1
        strParam2
        strParam3
        strTagHead
    }

    // 空きを探す(-1:なし)
    __fn _getEmptyIndex $dvPtr $dvHead $loop $size bl {
        v[__id($dvPtr)] = -1
        @loop $loop .dst(fA) bl {
            @if `v[__id($dvHead) + fA * ($size)] <= 0 bl {
                v[__id($dvPtr)] = fA
                @break
            }
        }
    }
    // 自機弾を初期化する
    __fn _initBullet $ptr $block bl {
        $block
        v[$ptr..$ptr + SIZE_OF_BU - 1] = [$state, $angle, $x, $y]
    }

    // 自機弾のポインタを取得する
    __fn _getBulletPtr $dvPtr $idx bl {
        v[__id($dvPtr)] = __id(buHead) + ($idx) * SIZE_OF_BU
    }

    // 的を初期化する
    __fn _initTarget $ptr $block bl {
        $block
        v[$ptr..$ptr + SIZE_OF_TAG - 1] = [$state, $angle, $hp, $damage, $x, $y]
    }

    // 的のポインタを取得する
    __fn _getTargetPtr $dvPtr $idx bl {
        v[__id($dvPtr)] = __id(tagHead) + ($idx) * SIZE_OF_TAG
    }

    // 的の文字列のポインタを取得する
    __fn _getTargetStrPtr $dvPtr $idx bl {
        v[__id($dvPtr)] = __id(strTagHead) + ($idx)
    }

    // 爆発を生成する
    __fn _createExplosion $x $y bl {
        fA = exploCount + PIC_EXPLO
        @pic.strpic [fA] "\c[2](())" .pos($x, $y) .center .trans(-200) .add baseStrPicCmd
        @pic.move [fA] .relative .pos(0, 0) .scale(50) .trans(300) .time(3) .keepBlend  
        exploCount = (exploCount + 1) % MAX_EX
    }

    // アイテムを生成する
    __fn _createItem $x $y bl {
        v[__id(itState)..__id(itY)] = [IT_ST_ENABLE, 0, $x, $y]
    }

    commentRangeOfVariables(varFoot, TV_MINIGAME, NUM_OF_VAR, NUM_OF_STR, NUM_OF_PIC)

    //------------------------------------------------------------------------------------
    //開始処理
    bl {
        //変数を初期化
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, TS_MINIGAME, NUM_OF_STR)
        //BGMを記憶する
        storeAndStopBGM()
        //メッセージの表示位置
        msgBottom()
        @label.jump "gameLoop"
    }

    //------------------------------------------------------------------------------------
    //ゲーム処理
    @label.set "gameLoop"
    bl {
        //変数を一括で初期化する
        assignVarUsingDeclared(varHead, varFoot, 0)

        V2_set(plX,
            (STAGE_WIDTH / 2) * UNIT_POS,
            (32) * UNIT_POS
        )

        //ピクチャを初期化する
        @pic.strpic [PIC_PLAYER] "\c[7]END" .pos(OUT_RANGE, OUT_RANGE) .trans(100) baseStrPicCmd
        @pic.strpic [PIC_ITEM] "\c[8](P)" .pos(OUT_RANGE, OUT_RANGE) .trans(100) baseStrPicCmd
        @loop MAX_BU .dst(pidA) bl {
            pidA += PIC_BULLET
            @pic.strpic [pidA] "\c[9]||" .pos(OUT_RANGE, OUT_RANGE) .trans(100) baseStrPicCmd 
        }
        
        //スライド
        @pic.show [PIC_BACK] PATH_BACK .pos(WINDOW_WIDTH + STAGE_WIDTH / 2, WINDOW_HEIGHT / 2) .scale2(STAGE_WIDTH * 100 / 16, STAGE_HEIGHT * 100 / 16) .trans(100) basePicCmd
        @pic.move [PIC_BACK] .relative .pos(- STAGE_WIDTH, 0) .scale2(0, 0) .trans(-50) .time(10)
        @wait(10)

        //コース読み込み
        strQueue.asg(STR_CREDIT)

        //BGM開始
        startBGM("AnoSora", FALSE, 0, 100, 100, 50)

        //----------------------------
        //ループ
        @loop bl {
            @wait(0)
            
            //----------------------------
            //ポーズ
            pauseProcces(TRUE, ipt, "gameEnd")
        
            //----------------------------
            //ゲーム進行
            stageDelay -= 1
            @while stageDelay <= 0 bl {
                //読み込む文字列がない
                strQueue .getLen(lenA)
                @if lenA <= 0 bl {
                    @break
                }
                //一行切り出し
                strQueue .popLine(strLine)
                strLine .split(",", strParam1, lenA)
                //分割数が足りない、あるいは多すぎる場合は読み飛ばす
                @if `!between(lenA, 2, 4) bl {
                    @continue
                }
                //待ち時間増加
                strParam1 .toNum(lenA)
                stageDelay += lenA * TAG_DELAY
                //位置
                strParam2 .toNum(pos)
                strParam2 .asg("")
                //内容
                @if strParam3 .eq("") bl {
                    @continue
                //スコアを表示する
                } .elif strParam3 .eq("s") bl {
                    strParam3 .asg(__str("ＳＣＯＲＥ：\", score))
                //アイテム
                } .elif strParam3 .eq("i") bl {
                    strParam2.asg("\c[7]")
                    strParam3 .asg(IT_STRING)
                //名前をランダムに決める
                } .elif strParam3 .eq("r") bl {
                    strParam3.asg("")
                    fA = rnd(0, FIRST_NAME_SIZE - 1)
                    fB = rnd(0, LAST_NAME_SIZE - 1)
                    @loop 1 bl {
                        __loop FIRST_NAME_LIST $str $idx bl {
                            @if fA == $idx bl {
                                strParam3.cat($str)
                                @break
                            }
                        }
                    }
                    @loop 1 bl {
                        __loop LAST_NAME_LIST $str $idx bl {
                            @if fB == $idx bl {
                                strParam3.cat($str)
                                @break
                            }
                        }
                    }
                }
                //空き場所を探す
                _getEmptyIndex(iA, tagHead, MAX_TAG, SIZE_OF_TAG)
                //空きが無かった
                @if iA < 0 bl {
                    @continue
                }
                //ピクチャを生成する
                pidA = PIC_TARGET + iA
                //色を付ける
                strParam1.asg(strParam2)
                strParam1.cat(strParam3)
                @pic.strpic [pidA] strParam1 .pos(OUT_RANGE, OUT_RANGE) .trans(100) baseStrPicCmd
                //位置を設定する
                @pic.getInfo [pidA] .currentRect(0, 0, bx, 0) .cewh
                //左寄せ,左,中央,右,右寄せ
                @if pos == 0 bl {
                    ax = 0
                } .elif pos == 1 bl {
                    ax = STAGE_WIDTH / 2
                } .elif pos == 2 bl {
                    ax = STAGE_WIDTH
                //例外
                } .else bl {
                    @continue
                }
                ax = clamp(ax, bx / 2 + 2, STAGE_WIDTH - bx / 2 - 2) * UNIT_POS
                //文字列入力
                _getTargetStrPtr(psA, iA)
                t[psA].asg(strParam3 .extract)
                //体力は文字列の長さに比例する
                strParam1.getLen(lenA)
                //設置する
                _getTargetPtr(pA, iA)
                _initTarget(pA,
                    bl {
                        $state = TAG_ST_CREATE
                        $angle = -90 * UNIT_ANG
                        $hp = lenA
                        $x = ax
                        $y = (STAGE_HEIGHT + 8) * UNIT_POS
                    }
                )
            }
            //読み込む文字列がない場合、終了する
            @if stageDelay <= 0 bl {
                strQueue .getLen(lenA)
                @if lenA <= 0 bl {
                    @label.jump "close"
                }
            }
            //----------------------------
            //プレイヤー
            //自動射撃
            @key.input .dst(ipt) {
                .shift
            }
            plAutoIpt = ipt ? plAutoIpt + 1 : 0
            //切り替え
            @if plAutoIpt == 1 bl {
                @se.play "Switch1" .opt(60, 100, 50)
                plAutoMode = !plAutoMode
            }
            //タイマー
            plTimer += 1
            //移動
            V2_getInput(ax)
            plX = clamp(plX + ax * PL_SPEED, PL_RAD, STAGE_WIDTH  * UNIT_POS - PL_RAD)
            plY = clamp(plY + ay * PL_SPEED, PL_RAD, STAGE_HEIGHT * UNIT_POS - PL_RAD)
            //射撃
            //攻撃入力
            @key.input .dst(ipt) {
                .decision
            }

            @if plAtkIpt > 0 bl {
                plAtkIpt -= 1
            } .elif `ipt || plAutoMode bl {
                //レベルが上がると連射速度が落ちる
                plAtkIpt = [10, 12, 14][plLevel]
                //3way
                ax = plLevel + 1
                ay = 0
                @loop ax .dst(iA) bl {
                    //空き場所を探す
                    _getEmptyIndex(iB, buHead, MAX_BU, SIZE_OF_BU)
                    //空きがない
                    @if iB < 0 bl {
                        @break
                    }
                    _getBulletPtr(pB, iB)
                    //射出角度
                    ang = 90
                    @if plLevel == 1 bl {
                        ang += [-10, 10][iA]
                    } .elif plLevel == 2 bl {
                        ang += [0, -10, 10][iA]
                    }
                    //初期化
                    _initBullet(pB,
                        bl {
                            $state = BU_ST_CREATE
                            $angle = ang * UNIT_ANG
                            $x = plX
                            $y = plY
                        }
                    )
                    //生成数
                    ay += 1
                }
                @if ay > 0 bl {
                    @se.play "Cursor1" .opt(60, 150, 50)
                }
            }
            //自機ピクチャ
            V2_set(ax,
                REF_X + plX / UNIT_POS,
                REF_Y + plY / UNIT_POS
            )
            //透明度
            @if plTimer < PL_INTERVAL bl {
                fA = plTimer % 4 < 2 ? 100 : 0
            } .else bl {
                fA = 0
            }
            @pic.move [PIC_PLAYER] .pos(ax,ay) .center .trans(fA)

            //自弾
            @loop MAX_BU .dst(iA) bl {
                _getBulletPtr(pA, iA)
                @if `v[pA + MB_STATE] <= BU_ST_NONE bl {
                    @continue
                }
                //ピクチャID
                pidA = iA + PIC_BULLET
                //生成直後は判定を行わない
                @if `v[pA + MB_STATE] == BU_ST_CREATE bl {
                    v[pA + MB_STATE] = BU_ST_ENABLE
                //的への攻撃判定
                } .else bl {
                    //ピクチャの表示位置で行う
                    @pic.getInfo [pidA] .currentRect(cx, cy, 0, 0) .cewh
                    @loop MAX_TAG .dst(iB) bl {
                        _getTargetPtr(pB, iB)
                        @if `v[pB + MT_STATE] != TAG_ST_ENABLE bl {
                            @continue
                        }
                        //ピクチャのID
                        pidB = iB + PIC_TARGET
                        //xywh
                        @pic.getInfo [pidB] .currentRect(ax, ay, bx, by) .xywh
                        //差
                        V2_sub(ax, cx, ax)
                        //衝突判定
                        @if `!between(ax, 0, bx) || !between(ay, 0, by) bl {
                            @continue
                        }
                        //弾丸を消去する
                        v[pA + MB_STATE] = BU_ST_DELETE
                        //HP減少
                        v[pB + MT_HP] -= BU_ATK
                        @if `v[pB + MT_HP] > 0 bl {
                            @se.play "Cancel1" .opt(40, 150, 50)                       
                            //点滅する
                            v[pB + MT_DAMAGE] = 4
                        } .else bl {
                            @se.play "Ice9" .opt(50, 120, 50)
                            //撃墜スコア
                            score += 1
                            //文字の位置
                            _getTargetStrPtr(psB, iB)
                            //文字の長さ
                            t[psB].getLen(lenB)
                            //文字の位置を記録する
                            //短すぎる場合は-1になる
                            v[pB + MT_DAMAGE] = clamp(muldiv(ax, lenB, bx), 0, lenB - 1)
                            //的を分解させる
                            v[pB + MT_STATE] = TAG_ST_DEFEAT
                            //爆発エフェクト
                            @pic.getInfo [pidB] .currentRect(ax, ay, bx, by) .cewh
                            ax += - bx / 2 + muldiv( bx, v[pB + MT_DAMAGE] * 2 + 1, lenB * 2 )
                            _createExplosion(ax, ay)
                        }
                    }
                }
                //移動
                ang = v[pA + MB_ANGLE]
                V2_getCosSin(ax, ang, UNIT_ANG, BU_SPEED)
                v[pA + MB_X] += ax
                v[pA + MB_Y] += ay
                //画面外判定
                @if `!between(v[pA + MB_X], 0, STAGE_WIDTH  * UNIT_POS) ||
                     !between(v[pA + MB_Y], 0, STAGE_HEIGHT * UNIT_POS) bl {
                    v[pA + MB_STATE] = BU_ST_DELETE
                }
                //変数の適用とピクチャの更新
                //削除
                @if `v[pA + MB_STATE] <= BU_ST_DELETE bl {
                    hidePicture(pidA)
                    v[pA + MB_STATE] = BU_ST_NONE
                //通常
                } .else bl {
                    V2_set(ax,
                        REF_X + v[pA + MB_X] / UNIT_POS,
                        REF_Y + v[pA + MB_Y] / UNIT_POS
                    )
                    @pic.move[pidA] .pos(ax, ay) .center
                }
            }

            //的
            //localA = 0
            @loop MAX_TAG .dst(iA) bl {
                _getTargetPtr(pA, iA)
                @if `v[pA + MT_STATE] <= TAG_ST_NONE bl {
                    @continue
                }
                //localA += 1
                //ピクチャID
                pidA = iA + PIC_TARGET
                //ピクチャの幅を取得する
                @pic.getInfo [pidA] .currentRect(0, 0, bx, by) .xywh
                //生成直後
                @if `v[pA + MT_STATE] == TAG_ST_CREATE bl {
                    v[pA + MT_STATE] = TAG_ST_ENABLE                    
                //分解
                } .elif `v[pA + MT_STATE] == TAG_ST_DEFEAT bl {
                    //この的は消去する
                    v[pA + MT_STATE] = TAG_ST_DELETE
                    //撃墜箇所
                    pos = v[pA + MT_DAMAGE]
                    //文字列の位置
                    _getTargetStrPtr(psA, iA)
                    //文字列の長さ
                    t[psA].getLen(lenA)
                    //タイプ
                    //アイテム
                    @if t[psA] .eq(IT_STRING) bl {
                        _createItem(v[pA + MT_X], v[pA + MT_Y])
                    //通常
                    } .else bl {
                        //左右に切り分ける
                        fA = pos + 1
                        fB = lenA - pos - 1
                        strParam1.asg("")
                        strParam2.asg("")
                        @if pos > 0 bl {
                            strParam1.asg.subs(t[psA], 0, pos)
                        }
                        @if fB > 0 bl {
                            strParam2.asg.subs(t[psA], fA, fB)
                        }

                        //的を生成する
                        @loop 2 .dst(ipt) bl {
                            //空き場所を探す
                            _getEmptyIndex(iB, tagHead, MAX_TAG, SIZE_OF_TAG)
                            //空き場所がない
                            @if iB < 0 bl {
                                @break
                            }
                            //文字列と生成位置と射出角度
                            //左
                            @if ipt == 0 bl {
                                strLine.asg(strParam1)
                                strLine.getLen(lenB)
                                ang = -90 - rnd(-20, 45)
                                ax = -bx / 2 + muldiv(bx, lenB, lenA) / 2
                            //右
                            } .else bl {
                                strLine.asg(strParam2)
                                strLine.getLen(lenB)
                                ang = -90 + rnd(-20, 45)
                                ax =  bx / 2 - muldiv(bx, lenB, lenA) / 2
                            }
                            ang *=  UNIT_ANG
                            ax *= UNIT_POS
                            //文字列が短すぎる
                            @if lenB <= 0 bl {
                                @continue
                            }
                            //文字列を設定する
                            _getTargetStrPtr(psB, iB)
                            t[psB].asg(strLine)
                            //生成する
                            _getTargetPtr(pB, iB)
                            _initTarget(pB,
                                bl {
                                    $state = TAG_ST_ENABLE
                                    $angle = ang
                                    $hp = lenB
                                    $damage = 4
                                    $x = v[pA + MT_X] + ax
                                    $y = v[pA + MT_Y]
                                }
                            )
                            //ピクチャを設置する
                            V2_set(ax,
                                REF_X + v[pB + MT_X] / UNIT_POS,
                                REF_Y + v[pB + MT_Y] / UNIT_POS
                            )
                            pidB = PIC_TARGET + iB
                            @pic.strpic [pidB] strLine .pos(OUT_RANGE, OUT_RANGE) .trans(100) baseStrPicCmd
                        }
                    }
                //生存
                } .else bl {
                    //速度を加算
                    //真上だと三角関数の取得を省略する
                    ang = v[pA + MT_ANGLE]
                    @if ang == -90 * UNIT_ANG bl {
                        v[pA + MT_Y] -= TAG_SPEED
                    } .else bl {
                        V2_getCosSin(ax, ang, UNIT_ANG, TAG_SPEED)
                        v[pA + MT_X] += ax
                        v[pA + MT_Y] += ay
                    }
                    //壁反射
                    ax = v[pA + MT_X]
                    ang = v[pA + MT_ANGLE]
                    fA = between(ang, -90 * UNIT_ANG, 90 * UNIT_ANG)
                    fb = bx * UNIT_POS / 2
                    @if `(ax < fb && !fA) || (ax > STAGE_WIDTH * UNIT_POS - fb && fA) bl {
                        v[pA + MT_ANGLE] = (ang > 0) ? (180 * UNIT_ANG - ang) : (-180 * UNIT_ANG - ang)
                    }
                    v[pA + MT_X] = clamp(v[pA + MT_X], fb, STAGE_WIDTH * UNIT_POS - fb)
                    //ダメージカウンタ
                    @if `v[pA + MT_DAMAGE] > 0 bl {
                        v[pA + MT_DAMAGE] -= 1
                    }
                    //プレイヤーとの衝突判定
                    //無敵時間とレベル
                    @if `plTimer > PL_INTERVAL && plLevel > 0 bl {
                        //ピクチャの幅を取得する
                        @pic.getInfo [pidA] .currentRect(0, 0, bx, by) .xywh
                        V2_set(ax,
                            plX - v[pA + MT_X],
                            plY - v[pA + MT_Y]
                        )
                        @if `abs(ax) < bx * UNIT_POS / 2 && abs(ay) < by * UNIT_POS / 2 bl {
                            @se.play "explo1" .opt(70, 100, 50)
                            //撃墜
                            plTimer = 0
                            plLevel -= 1
                            //爆発エフェクト
                            @pic.getInfo [PIC_PLAYER] .currentRect(ax, ay, 0, 0) .cewh
                            _createExplosion(ax, ay)
                        }
                    }
                }
                //画面外判定
                @if `!between(v[pA + MT_Y], -16 * UNIT_POS, (STAGE_HEIGHT + 16) * UNIT_POS) bl {
                    v[pA + MT_STATE] = TAG_ST_DELETE
                }
                //削除
                @if `v[pA + MT_STATE] <= TAG_ST_DELETE bl {
                    @pic.move[pidA] .pos(OUT_RANGE, OUT_RANGE) .center .trans(100)
                    v[pA + MT_STATE] = TAG_ST_NONE
                //通常
                } .else bl {
                    V2_set(ax,
                        REF_X + v[pA + MT_X] / UNIT_POS,
                        REF_Y + v[pA + MT_Y] / UNIT_POS
                    )
                    //色
                    @if `v[pA + MT_DAMAGE] > 0 bl {
                        v[__id(fA)..__id(fB)] = [200, 0]
                    } .else bl {
                        v[__id(fA)..__id(fB)] = [100, 100]
                    }
                    @pic.move[pidA] .pos(ax, ay) .center .rgbs(fA, fB, fB, fB)
                }
            }

            //db_log(__str("target:\",localA))

            //アイテム
            @if itState > IT_ST_NONE bl {
                itTimer += 1
                //プレイヤーとの衝突判定
                @if `abs(plX - itX) < PL_RAD + IT_RAD && abs(plY - itY) < PL_RAD + IT_RAD bl {
                    itState = IT_ST_DELETE
                    @if plLevel < PL_MAX_LEVEL bl {
                        @se.play "Buff" .opt(70, 120, 50)
                        plLevel += 1
                    } .else bl {
                        @se.play "bubble1" .opt(60, 120, 50)
                    }
                    plTimer = 0
                }
                //位置を更新する
                itY -= IT_SPEED
                //画面外判定
                @if `itY < 16 * UNIT_POS bl {
                    itState = IT_ST_DELETE
                }
                //ピクチャID
                pidA = PIC_ITEM
                @if itState == IT_ST_DELETE bl {
                    itState = IT_ST_NONE
                    hidePicture(pidA)
                } .else bl {
                    V2_set(ax,
                        REF_X + itX / UNIT_POS,
                        REF_Y + itY / UNIT_POS
                    )
                    fA = (itTimer % 20 < 5) ? 200 : 100
                    @pic.move[pidA] .pos(ax, ay) .center .rgbs(fA, fA, fA, fA)
                }
            }
        }
    }

    //------------------------------------------------------------------------------------
    //終了する
    @label.set "close"
    bl {
        //ピクチャ初期化
        @loop MAX_BU .dst(pidA) bl {
            pidA += PIC_BULLET
            hidePicture(pidA)
        }
        @loop MAX_TAG .dst(pidA) bl {
            pidA += PIC_TARGET
            hidePicture(pidA)
        }

        stopBGM(2000)
        @wait(20)

        hidePicture(PIC_PLAYER)
        @pic.move [PIC_BACK] .relative .pos(STAGE_WIDTH, 0) .scale2(0, 0) .trans(50) .time(10)
        @wait(10)

        @label.jump "gameEnd"
    }

    //------------------------------------------------------------------------------------
    //終了する
    @label.set "gameEnd"
    bl {
        //ピクチャ、変数を初期化
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, TS_MINIGAME, NUM_OF_STR)
        //BGMを再生する
        restoreBGM()
    }
}