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

cev[CEV_LIGHT_UP] .name("mg_ライトアップ") {
    def {
        //使用する変数の個数
        NUM_OF_VAR = 256
        NUM_OF_STR = 0
        NUM_OF_PIC = 100
        //レイヤー
        BASE_LAYER = 6
        //ピクチャパス
        PATH_FADE      = "cm\p8pa"
        PATH_FRAME     = "lu\fr"
        PATH_BACK      = "lu\ba"
        PATH_CLOUD     = "lu\cl"
        PATH_CHARA     = "lu\ch"
        PATH_MID_CHARA = "lu\mc"
        PATH_PARTICLE  = "lu\pt"
        PATH_LIFE      = "lu\li"
        PATH_SMALL_NUM = "lu\sn"
        PATH_FONT      = "lu\fo"
        PATH_TITLE     = "lu\ti"
        PATH_STAGE_DATA= "lu\st"
        //ピクチャID
        PIC_HEAD        = 1
        PIC_STAGE_DATA  = 2
        PIC_BACK        = 3
        PIC_BACK_CLOUD  = 5//+0_+2
        PIC_STAR        = 10//+0_+11
        PIC_ROCK        = 25//+0_+3
        PIC_PLAYER      = 30//+0_+2
        PIC_ENEMY       = 35//+0_+3
        PIC_PARTICLE    = 40//+0_+15
        PIC_FRONT_CLOUD = 60//+0_+2
        PIC_ADD_SCORE   = 65//+0_+2
        PIC_TITLE       = 70//+0_+2
        PIC_LIFE        = 73
        PIC_SCORE       = 74//+0_+5
        PIC_STAGE       = 80//+0_+4
        PIC_STRING      = 85//+0_+11
        PIC_FADE        = 98
        PIC_FRAME       = 99

        //シーン
        SC_ST_TITLE = 0
        SC_ST_GAME
        SC_ST_START
        SC_ST_SELECT_STAGE
        SC_ST_LOAD
        SC_ST_CLEAR
        SC_ST_ALLCLEAR
        SC_ST_GAMEOVER

        //トリガー
        TR_BIT_INIT_PIC    = 1 << 0
        TR_BIT_SCORE       = 1 << 1
        TR_BIT_ADD_SCORE   = 1 << 2
        TR_BIT_LIFE        = 1 << 3
        TR_BIT_STAGE       = 1 << 4

        //ビット
        CH_BIT_HREV   = 1 << 0
        CH_BIT_GROUND = 1 << 1
        CH_BIT_LOCK   = 1 << 2

        //プレイヤー
        PL_ST_NONE = 0
        PL_ST_GROUND
        PL_ST_AIR
        PL_ST_DAMAGE

        PL_GRAVITY = 1
        PL_WALK_VX = 15
        PL_JUMP_VY = 15
        PL_MAX_VY  = 30
        PL_DAMAGE_TIME_1 = 60
        PL_DAMAGE_TIME_2 = 20
        PL_DAMAGE_VX     = -10
        PL_DAMAGE_VY     = -15
        PL_X = SCREEN_WIDTH / 2
        PL_Y = SML_SPR_SIZE * 15

        //パーティクル
        MAX_PARTICLE = 16
        PA_FRAME = 4
        PA_INTERVAL = 3

        MP_CELL = 0
        MP_TIMER
        MP_X
        MP_Y
        MP_VX
        MP_VY
        SIZE_OF_PARTICLE

        //星
        MAX_STAR = 12

        MS_STATE = 0
        MS_TIMER
        MS_X
        MS_Y
        SIZE_OF_STAR

        ST_ST_NONE = 0
        ST_ST_DELETE
        ST_ST_WAIT
        ST_ST_ACTIVE
        ST_ST_INIT

        //岩
        MAX_ROCK = 2
        RO_CEIL  = SML_SPR_SIZE * 3
        RO_THICK = 10
        RO_VX = 10
        RO_VY = 10
        RO_MY = 12

        MR_STATE = 0
        MR_TIMER
        MR_X
        MR_Y
        MR_VX
        MR_VY
        SIZE_OF_ROCK

        RO_ST_NONE = 0
        RO_ST_DELETE
        RO_ST_GROUND
        RO_ST_FALL
        RO_ST_UP

        //敵
        MAX_ENEMY = 3
        EN_RAD    = 8
        EN_WIDTH  = 16
        EN_HEIGHT = 16

        EN_REF_SPEED    = 10
        EN_REF_RND      = 20
        EN_LOOP_SPEED   = 10
        EN_CHASE_SPEED  = 5
        EN_CHASE_ROTATE = 2
        EN_SPEED_UP     = 4
        EN_UFO_SPEED    = 5
        EN_UFO_THICK    = 2
        EN_UFO_TIMER    = UNIT_FPS * 6
        EN_UFO_STAGE    = 4

        ME_STATE = 0
        ME_TIMER
        ME_TYPE
        ME_PARAM_1
        ME_X
        ME_Y
        SIZE_OF_ENEMY

        EN_ST_NONE = 0
        EN_ST_DELETE
        EN_ST_ACTIVE
        EN_ST_DEFEAT
        EN_ST_INIT

        EN_TYPE_NONE = 0
        EN_TYPE_REFLECT
        EN_TYPE_LOOP
        EN_TYPE_CHASE
        EN_TYPE_UFO

        //スコア
        MAX_SCORE = 99999
        SCORE_DIGIT = 5
        SCORE_X = 42
        SCORE_Y = 1
        ADD_SCORE_DIGIT = 3
        MAX_COMBO = 99
        COMBO_TIMER = 60
        SCORE_STAR = 10
        SCORE_UFO  = 100

        //ライフ
        MAX_LIFE = 3
        LIFE_X = SCREEN_WIDTH / 2
        LIFE_Y = 6

        //ステージ
        MAX_LAP = 2
        MAX_STAGE = 12
        UFO_INTERVAL = 4
        UFO_Y = SML_SPR_SIZE * 3
        STAGE_NUM_X = 104
        STAGE_NUM_Y = 1
        STAGE_NUM_DIGIT = 2
        STAGE_NUM_PIC = 5
        STAGE_MAP_SIZE = 16

        //文字列
        LI_ST_NONE = 0
        LI_ST_DELETE
        LI_ST_FIX
        LI_ST_PUT
        LI_ST_EASING

        //
        OUT_RANGE = -320
        UNIT_POS = 10
        SCREEN_WIDTH  = 128
        SCREEN_HEIGHT = 128
        FADE_TIME = 16
        GROUND_Y = 120
        MAX_STRING = 12
        CLOUD_WIDTH  = SCREEN_WIDTH / 2
        CLOUD_NUMER = 3
        REF_X = 104
        REF_Y = 56
        MID_FONT_WIDTH = 8
        SML_FONT_WIDTH  = 4
        SML_SPR_SIZE  = 8
        MID_SPR_SIZE = 16
        RESULT_X = 44
        RESULT_Y = 56

        //
        IN_GAME = sceneState != SC_ST_TITLE
        INPUT_DECISION = (iptDec == 1 || iptY == -1) && sceneTimer > 30
        
    }

    //アルファベット
    def {
        _A = 1
        _B
        _C
        _D
        _E
        _F
        _G
        _H
        _I
        _J
        _K
        _L
        _M
        _N
        _O
        _P
        _Q
        _R
        _S
        _T
        _U
        _V
        _W
        _X
        _Y
        _Z
        _EX
        _QU
        _SP
        _U0
        _U1
        _U2
        _0
        _1
        _2
        _3
        _4
        _5
        _6
        _7
        _8
        _9
        _SL
    }


    //ピクチャの共通コマンド
    def {
        basePicCmd = bl {
            .chromakey(1)
            .mapLayer(BASE_LAYER)
            .eraseWhenTransfer
            .affectedByFlash
            .affectedByShake
        }

        cloudPicCmd = bl {
            PATH_CLOUD
            .grid(1,2)
            basePicCmd
        }

        charaPicCmd = bl {
            PATH_CHARA
            .grid(8,2)
            basePicCmd
        }

        midCharaPicCmd = bl {
            PATH_MID_CHARA
            .grid(8,4)
            basePicCmd
        }

        partPicCmd = bl {
            PATH_PARTICLE
            .grid(8,3)
            basePicCmd
        }

        lifePicCmd = bl {
            PATH_LIFE
            .grid(1,4)
            basePicCmd
        }

        smallNumberPicCmd = bl {
            PATH_SMALL_NUM
            .grid(10,1)
            basePicCmd
        }
        
        fontPicCmd = bl {
            PATH_FONT
            .grid(16,3)
            basePicCmd
        }

        titlePicCmd = bl {
            PATH_TITLE
            .grid(2,2)
            basePicCmd
        }

        fadePicCmd = bl {
            PATH_FADE
            .grid(16, 1)
            basePicCmd
        }
    }

    defv {
        varHead = TV_MINIGAME

        ipt
        pid
        cell
        state
        timer
        type
        ang
        rad
        pA
        pB
        iA
        iB
        fA
        fB
        ax
        ay
        bx
        by

        triggerFlg
        sceneState
        sceneTimer
        fadeTimer

        iptX
        iptY
        iptDec

        lineState
        lineLen
        lineX
        lineY

        initHead

        score
        addScore
        addScoreX
        addScoreY
        updateHighScore
        comboCount
        comboTimer
        stageCount
        stageLap
        stageType
        stageBit
        starCount
        enemyNumber
        enemyCount
        bgScroll
        particleIdx

        plState
        plTimer
        plBit
        plLife
        plInv
        plX
        plY
        plVx
        plVy
        plSx
        plSy
        plEffX_1
        plEffY_1
        plEffX_2
        plEffY_2

        partHead 
        starHead = __id(partHead) + MAX_PARTICLE * SIZE_OF_PARTICLE
        rockHead = __id(starHead) + MAX_STAR * SIZE_OF_STAR
        enemyHead = __id(rockHead) + MAX_ROCK * SIZE_OF_ROCK

        varFoot = __id(enemyHead) + MAX_ENEMY * SIZE_OF_ENEMY
    }
    //変数の範囲を見る
    commentRangeOfVariables(varFoot, TV_MINIGAME, NUM_OF_VAR, NUM_OF_STR, NUM_OF_PIC)

    //ステージの種類に対応した文字(12文字)
    def ZODIAC_ARRAY =
    [_A,_R,_I,_E,_S, 0, 0, 0, 0, 0, 0, 0,//ARIES
     _T,_A,_U,_R,_U,_S, 0, 0, 0, 0, 0, 0,//TAURUS
     _G,_E,_M,_I,_N,_I, 0, 0, 0, 0, 0, 0,//GEMINI
     _C,_A,_N,_C,_E,_R, 0, 0, 0, 0, 0, 0,//CANCER
     _L,_E,_O, 0, 0, 0, 0, 0, 0, 0, 0, 0,//LEO
     _V,_I,_R,_G,_O, 0, 0, 0, 0, 0, 0, 0,//VIRGO
     _L,_I,_B,_R,_A, 0, 0, 0, 0, 0, 0, 0,//LIBRA
     _S,_C,_O,_R,_P,_I,_O, 0, 0, 0, 0, 0,//SCORPIO
     _S,_A,_G,_G,_I,_T,_A,_R,_I,_U,_S, 0,//SAGGITARIUS
     _C,_A,_P,_R,_I,_C,_O,_R,_N, 0, 0, 0,//CAPRICORN
     _A,_Q,_U,_A,_R,_I,_U,_S, 0, 0, 0, 0,//AQUARIUS
     _P,_I,_S,_C,_E,_S, 0, 0, 0, 0, 0, 0,//PISCES
      0]

    //一周した時のコメント
    def RESULT_ARRAY =
    [_A,_L,_L,_SP,_C,_L,_E,_A,_R,_EX, 0, 0,//ALL CLEAR!
     _P,_E,_R,_F,_E,_C,_T,_EX, 0, 0, 0, 0,//PERFECT!
     _S,_U,_G,_O,_I,_EX, 0, 0, 0, 0, 0, 0,//SUGOI!
     0
    ]
    //ステージ番号に応じた敵の組み合わせ(3つ)
    def ENEMY_ARRAY =
    [ 1, 1, 1,
      1, 1, 2,
      1, 2, 2,
      1, 1, 0,
      2, 1, 1,
      2, 3, 1,
      2, 2, 2,
      2, 2, 0,
      3, 1, 1,
      1, 1, 1,
      3, 2, 2,
      1, 1, 0,
      0
    ]

    //ステージに設置する敵の数を取得する
    //最初だけ1体のみ
    __fn _getEnemyNumber $dvNum bl {
        @if stageCount == 0 bl {
            v[__id($dvNum)] = 1
        } .else bl {
            v[__id($dvNum)] = [2,3,3][stageLap]
        }
    }

    //シーンの状態を変える
    __fn _changeSceneState $state bl {
        v[__id(sceneState)..__id(sceneTimer)] = [$state, -1]
    }
    //数値を表示する
    //fA, fB, ax, ay, pid, cell
    __fn _showCounter $num $pid $dig $width $x $y bl {
        fB = 1
        @loop $dig .dst(fA) bl {
            v[__id(ax)..__id(ay)] = [($x) - fA * $width, ($y)]
            pid  = ($pid) + fA
            cell = (($num) < fB && fB != 1) ? (0) : (_0 + ($num) % (fB * 10) / fB)
            @pic.show [pid] .pos(ax, ay) .topRight .scale(100) .cell(cell) fontPicCmd  
            //次の桁
            fB *= 10
        }
    }
    //文字を設置する
    //fA
    __fn _setString $arr $len $state $ix $iy $cx $cy bl {
        v[__id(lineState)..__id(lineY)] = [$state, $len, $cx, $cy]
        @foreach $arr .dst(fA) {
            pid = PIC_STRING + fB
            @pic.show[pid] .pos(REF_X + ($ix), REF_Y + ($iy)) .center .cell(fA) fontPicCmd
        }
    }
    //スコアを追加する
    __fn _addScore $score $combo $x $y bl {
        __if $combo > 0 bl {
            comboCount = min(comboCount + ($combo), MAX_COMBO)
            comboTimer = COMBO_TIMER
            v[__id(addScore)..__id(addScoreY)] = [addScore + ($score), $x, $y]
            bitOn(triggerFlg, TR_BIT_ADD_SCORE)
        } .else bl {
            score = min(score + $score, MAX_SCORE)
            bitOn(triggerFlg, TR_BIT_SCORE)
        }
    }
    //フェードイン
    __fn _fadeIn bl {
        fadeTimer = FADE_TIME + 1
    }
    //プレイヤーをリフトに乗せる
    __fn _putPlayerOnLift $y $vx $vy bl {
        bitOn(plBit, CH_BIT_GROUND)
        plY = $y
        plVy = $vy
        plSx = $vx
    }
    //プレイヤーにダメージを与える
    __fn _damageToPlayer $hrev bl {
        bitOn(triggerFlg, TR_BIT_LIFE)
        _changePlayerState(PL_ST_DAMAGE)
        plLife -= 1
        plInv = PL_DAMAGE_TIME_1
        //後ろに跳ねる
        v[__id(plVx)..__id(plVy)] = [($hrev) ? (-PL_DAMAGE_VX) : (PL_DAMAGE_VX), PL_DAMAGE_VY]
    }
    //プレイヤーの状態を変える
    __fn _changePlayerState $state bl {
        v[__id(plState)..__id(plTimer)] = [$state, -1]
    }
    //パーティクルを初期化する
    __fn _initParticle $ptr $block bl {
        $block
        v[$ptr..$ptr + SIZE_OF_PARTICLE - 1] = [$cell, $timer, $x, $y, $vx, $vy]
    }
    //パーティクルのポインタを取得する
    __fn _getParticlePtr $dvPtr $idx bl {
        v[__id($dvPtr)] = __id(partHead) + ($idx) * SIZE_OF_PARTICLE
    }
    //パーティクルのインデックスを進める
    __fn _nextParticle bl {
        particleIdx += 1
        particleIdx %= MAX_PARTICLE
    }
    //敵を初期化する
    __fn _initEnemy $ptr $block bl {
        $block
        v[$ptr..$ptr + SIZE_OF_ENEMY - 1] = [$state, $timer, $type, $param1, $x, $y]
    }
    //敵のポインタを取得する
    __fn _getEnemyPtr $dvPtr $idx bl {
        v[__id($dvPtr)] = __id(enemyHead) + ($idx) * SIZE_OF_ENEMY
    }
    //敵の状態を変える
    __fn _changeEnemyState $ptr $state bl {
        v[$ptr + ME_STATE..$ptr + ME_TIMER] = [$state, -1]
    }
    //星を初期化する
    __fn _initStar $ptr $block bl {
        $block
        v[$ptr..$ptr + SIZE_OF_STAR - 1] = [$state, $timer, $x, $y]
    }
    //星のポインタを取得する
    __fn _getStarPtr $dvPtr $idx bl {
        v[__id($dvPtr)] = __id(starHead) + ($idx) * SIZE_OF_STAR
    }
    //星の状態を変える
    __fn _changeStarState $ptr $state bl {
        v[$ptr + MS_STATE..$ptr + MS_TIMER] = [$state, -1]
    }
    //岩を初期化する
    __fn _initRock $ptr $block bl {
        $block
        v[$ptr..$ptr + SIZE_OF_ROCK - 1] = [$state, $timer, $x, $y, $vx, $vy]
    }
    //岩のポインタを取得する
    __fn _getRockPtr $dvPtr $idx bl {
        v[__id($dvPtr)] = __id(rockHead) + ($idx) * SIZE_OF_ROCK
    }
    //岩の状態を変える
    __fn _changeRockState $ptr $state bl {
        v[$ptr + MR_STATE..$ptr + MR_TIMER] = [$state, -1]
    }

    //------------------------------------------------------------------------------------
    //開始処理
    bl {
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, TS_MINIGAME, NUM_OF_STR)
        storeAndStopBGM()
        msgBottom()
        @scr.tint .rgbs(50, 50, 50, 100) .time(1)
        //枠
        @pic.show[PIC_FRAME] PATH_FRAME .pos(0, 0) .topLeft basePicCmd
        //ステージデータ
        @pic.show[PIC_STAGE_DATA] PATH_STAGE_DATA .pos(0,0) .topLeft .trans(100) basePicCmd
        //無敵モード
        //invincibleSwitch.on
        @label.jump "gameLoop"
    }

    //------------------------------------------------------------------------------------
    //ゲーム処理
    @label.set "gameLoop"
    bl {
        //入力抑制
        iptDec = 2
        //ハイスコアをタイトルに表示する
        score = lightupScore
        //タイトル
        _changeSceneState(SC_ST_TITLE)
        _fadeIn()

        //----------------------------
        //ループ
        @loop bl {
            @wait(0)
            //----------------------------
            //ポーズ
            pauseProcces(TRUE, ipt, "gameEnd")

            //----------------------------
            //入力
            V2_getInput(iptX)
            //決定
            @key.input .dst(ipt) .decision
            iptDec = ipt ? iptDec + 1 : 0

            //----------------------------
            //シーン
            sceneTimer += 1

            pseudoSwitchState(sceneState,
            //ゲームシーン
            [ SC_ST_GAME, bl {
                //BGM
                @if sceneTimer == 0 bl {
                    startBGM("starlight1_chiptune", FALSE, 0, 90, 100, 50)
                }

                //ゲームオーバー
                @if plState == PL_ST_NONE bl {
                    _changeSceneState(SC_ST_GAMEOVER)
                //ステージクリア
                } .elif starCount <= 0 bl {
                    _changeSceneState(SC_ST_CLEAR)
                }
            },
            //スタート
            SC_ST_START, bl {
                //START
                _setString([_S,_T,_A,_R,_T], 5, LI_ST_PUT, -16, -16, SCREEN_WIDTH  / 2, SCREEN_HEIGHT / 2)

                //画面初期化
                bitOn(triggerFlg, TR_BIT_SCORE | TR_BIT_LIFE)

                //ステージ初期化
                stageBit = 0
                starCount = 0
                enemyCount = 0
                
                //プレイヤー初期化
                V2_set(plX, PL_X * UNIT_POS, PL_Y * UNIT_POS)
                V2_set(plVx, 0, PL_GRAVITY)
                V2_set(plEffX_1, -1 * SML_SPR_SIZE * UNIT_POS, -1 * SML_SPR_SIZE * UNIT_POS)
                V2_set(plEffX_2, -1 * SML_SPR_SIZE * UNIT_POS, -1 * SML_SPR_SIZE * UNIT_POS)
                _changePlayerState(PL_ST_GROUND)
                plBit = 0
                plLife = MAX_LIFE
                plInv = 0

                //岩を設置する
                @loop MAX_ROCK .dst(iA) bl {
                    //左右に割り振る
                    ax = [rnd(1,7), rnd(9, 14)][iA % 2]
                    ay = RO_MY

                    _getRockPtr(pA, iA)
                    _initRock(pA, bl {
                        $state = RO_ST_FALL
                        $x = (ax * SML_SPR_SIZE + SML_SPR_SIZE / 2) * UNIT_POS
                        $y = (ay * SML_SPR_SIZE + SML_SPR_SIZE / 2) * UNIT_POS
                        $vy = RO_VY
                    } )
                }
                //星を消す
                @loop MAX_STAR .dst(iA) bl {
                    _getStarPtr(pA, iA)
                    @if `v[pA + MS_STATE] <= ST_ST_NONE bl {
                        @continue
                    }
                    _changeStarState(pA, ST_ST_DELETE)
                }
                //ゲームスタート
                _changeSceneState(SC_ST_SELECT_STAGE)
            },
            //次のステージを選ぶ
            SC_ST_SELECT_STAGE, bl {
                //ステージ選択
                @if sceneTimer == 0 bl {
                    selectUsingBit(stageType, __id(stageBit), MAX_STAGE)
                }
                //ステージ読み込み
                @if stageType >= 0 bl {
                    _changeSceneState(SC_ST_LOAD)
                //少し待ってからクリアシーンに移行する
                } .elif sceneTimer > 90 bl {
                    _changeSceneState(SC_ST_ALLCLEAR)
                    lineState = LI_ST_DELETE
                }
            },
            //ステージを進める
            SC_ST_LOAD, bl {
                @if sceneTimer == 0 bl {
                    //星を消す
                    @loop MAX_STAR .dst(iA) bl {
                        _getStarPtr(pA, iA)
                        @if `v[pA + MS_STATE] <= ST_ST_NONE bl {
                            @continue
                        }
                        _changeStarState(pA, ST_ST_DELETE)

                        //パーティクル
                        _getParticlePtr(pB, particleIdx)
                        _initParticle(pB, bl {
                            $cell = 1
                            $timer = -1
                            $x = v[pA + MS_X]
                            $y = v[pA + MS_Y]
                            $vy = -1 * UNIT_POS / 5
                        } )
                        _nextParticle()
                    }
                    starCount = 0

                    //敵の数
                    _getEnemyNumber(enemyNumber)
                    enemyCount = 0

                    //敵を設置する
                    iA = 0
                    iB = stageCount % MAX_STAGE
                    @foreach ENEMY_ARRAY .dst(fA) {
                        $HEAD = iB * MAX_ENEMY
                        $TAIL = (iB + 1) * MAX_ENEMY - 1
                        @if `between(fB, $HEAD, $TAIL) bl {
                            @if `fA > 0 && iA < enemyNumber bl {
                                _getEnemyPtr(pA, iA)
                                _initEnemy(pA, bl {
                                    $state = EN_ST_INIT
                                    $timer = -1
                                    $type = fA
                                    $x = -16 * UNIT_POS
                                    $y = 0
                                } )
                                iA += 1
                            }
                            @if `fB >= $TAIL bl {
                                @break
                            }
                        }
                    }

                    //UFOを置く
                    @if `stageCount > 0 && stageCount % UFO_INTERVAL == UFO_INTERVAL - 1 bl {
                        iA = MAX_ENEMY - 1
                        _getEnemyPtr(pA, iA)
                        _initEnemy(pA, bl {
                            $state = EN_ST_INIT
                            $timer = -1
                            $type = EN_TYPE_UFO
                            $x = -16 * UNIT_POS
                            $y = 0
                        } )
                    }

                    //ステージのカウントを進める
                    stageCount += 1
                    bitOn(triggerFlg, TR_BIT_STAGE)
                }

                //一行ずつ読み込む
                $FRAME = 4
                @if `!(sceneTimer % $FRAME) bl {
                    ax = stageType * STAGE_MAP_SIZE
                    ay = sceneTimer / $FRAME
                    @if `ay < STAGE_MAP_SIZE bl {
                        @loop STAGE_MAP_SIZE .dst(iA) bl {
                            V2_set(bx, ax + iA, ay)
                            @pic.getInfo [PIC_STAGE_DATA] .pixel(bx, by, 1, 1) .dst(ipt) .ignoreA .static
                            
                            //設置座標
                            V2_set(bx,
                                (iA * SML_SPR_SIZE + SML_SPR_SIZE / 2) * UNIT_POS,
                                (ay * SML_SPR_SIZE + SML_SPR_SIZE / 2) * UNIT_POS
                            )

                            //赤色に星を置く
                            @if `ipt & 0x00ff0000 bl {
                                @if starCount < MAX_STAR bl {
                                    _getStarPtr(pA, starCount)
                                    _initStar(pA, bl {
                                        $state = ST_ST_INIT
                                        $x = bx
                                        $y = by
                                    } )
                                    starCount += 1
                                }
                            }

                            //緑色に月を置く
                            @if `ipt & 0x0000ff00 bl {
                                _getEnemyPtr(pA, enemyCount)
                                //既に生成されている月の位置を設定する
                                @if `v[pA + ME_STATE] > EN_ST_NONE bl {
                                    v[pA + ME_X] = bx
                                    v[pA + ME_Y] = by
                                    enemyCount += 1
                                }
                            }
                        }
                    }
                }

                //開始する
                @if sceneTimer > 90 bl {
                    _changeSceneState(SC_ST_GAME)
                    lineState = LI_ST_DELETE
                }
            },
            //ステージクリア
            SC_ST_CLEAR, bl {
                @if sceneTimer == 0 bl {
                    //プレイヤーのライフを回復させる
                    @if plLife < MAX_LIFE bl {
                        bitOn(triggerFlg, TR_BIT_LIFE)
                        plLife = MAX_LIFE
                    }

                    //月を消してエフェクトを散らす
                    @loop MAX_ENEMY .dst(iA) bl {
                        _getEnemyPtr(pA, iA)
                        @if `v[pA + ME_STATE] <= EN_ST_NONE bl {
                            @continue
                        }
                        _changeEnemyState(pA, EN_ST_DELETE)

                        //パーティクル
                        @loop 3 .dst(iB) bl {
                            ang = iB * 120 + rnd(-30, 30)
                            _getParticlePtr(pB, particleIdx)
                            _initParticle(pB, bl {
                                $cell = 21
                                $timer = -1
                                $x = v[pA + ME_X] + cos(ang, 1, 4)
                                $y = v[pA + ME_Y] + sin(ang, 1, 4)
                                $vx = cos(ang, 1, 10)
                                $vy = sin(ang, 1, 10)
                            } )
                            _nextParticle()
                        }
                    }
                    enemyNumber = 0
                    enemyCount = 0

                    //文字を並べる
                    iA = 0
                    @foreach ZODIAC_ARRAY .dst(fA) {
                        $HEAD = stageType * MAX_STRING
                        $TAIL = (stageType + 1) * MAX_STRING - 1
                        @if `between(fB, $HEAD, $TAIL) bl {
                            @if fA > 0 bl {
                                pid = PIC_STRING + fB % MAX_STRING
                                cell = fA
                                @pic.show[pid] .pos(REF_X + SCREEN_WIDTH / 2, REF_Y - 8) .center .cell(cell) fontPicCmd
                                iA += 1
                            }
                            @if `fB >= $TAIL bl {
                                @break
                            }
                        }
                    }
                    v[__id(lineState)..__id(lineY)] = [LI_ST_EASING, iA, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2]

                    @se.play "fc_up1" .opt(90, 100, 50)
                }

                //次のステージへ
                @if sceneTimer > 60 bl {
                    _changeSceneState(SC_ST_SELECT_STAGE)
                }
            },
            //全ステージクリア
            SC_ST_ALLCLEAR, bl {
                //ALLCLEAR
                @if sceneTimer == 0 bl {
                    @pic.show [PIC_TITLE + 0] .pos(REF_X, REF_Y + 32) .topLeft .cell(2) titlePicCmd
                    @pic.show [PIC_TITLE + 1] .pos(REF_X + 32, REF_Y) .topLeft .cell(4) titlePicCmd

                    //文字を並べる
                    iA = 0
                    @foreach RESULT_ARRAY .dst(fA) {
                        $HEAD = stageLap * MAX_STRING
                        $TAIL = (stageLap + 1) * MAX_STRING - 1
                        @if `between(fB, $HEAD, $TAIL) bl {
                            @if fA > 0 bl {
                                pid = PIC_STRING + fB % MAX_STRING
                                cell = fA
                                @pic.show[pid] .pos(REF_X - 8, REF_Y - 8) .center .cell(cell) fontPicCmd
                                iA += 1
                            }
                            @if `fB >= $TAIL bl {
                                @break
                            }
                        }
                    }
                    v[__id(lineState)..__id(lineY)] = [LI_ST_EASING, iA, RESULT_X, RESULT_Y]

                    //プレイヤーを操作不能に
                    bitOn(plBit, CH_BIT_LOCK)

                    stopBGM()
                    @se.play "fc_clear03" .opt(90, 80, 50)
                }

                //身体が上下する
                @pic.move[PIC_TITLE + 0] .pos(REF_X, REF_Y) .topLeft .time(2)
                fA = sin(sceneTimer * 2, 1, 3)
                V2_set(ax,
                    REF_X,
                    REF_Y + fA + 3,
                )
                @pic.move[PIC_TITLE + 1] .pos(ax, ay) .topLeft .time(2)
                
                //タイトルに戻る
                @if `INPUT_DECISION bl {
                    @if stageLap >= MAX_LAP bl {
                        _changeSceneState(SC_ST_TITLE)
                        bitOn(triggerFlg, TR_BIT_INIT_PIC)
                        _fadeIn()
                    //次の周回へ
                    } .else bl {
                        _changeSceneState(SC_ST_START)
                        stageBit = 0
                        stageLap += 1
                    }

                    //消去
                    hidePicture(PIC_TITLE + 0)
                    hidePicture(PIC_TITLE + 1)
                    lineState = LI_ST_DELETE
                    _fadeIn()

                    @se.stop
                    @se.play "fc_coin1" .opt(90, 80, 50)
                }
            },
            //ゲームオーバー
            SC_ST_GAMEOVER, bl {
                //GAMEOVER
                @if sceneTimer == 0 bl {
                    bitOn(plBit, CH_BIT_LOCK)
                    _setString([_G,_A,_M,_E,_O,_V,_E,_R], 8, LI_ST_PUT, -16, -16, SCREEN_WIDTH  / 2, SCREEN_HEIGHT / 2)
                    stopBGM()
                }

                //ボタンを押すとタイトルに戻る
                @if `INPUT_DECISION bl {
                    _changeSceneState(SC_ST_TITLE)

                    lineState = LI_ST_DELETE
                    bitOn(triggerFlg, TR_BIT_INIT_PIC)

                    _fadeIn()
                    @se.play "fc_coin1" .opt(90, 80, 50)
                }
            },
            //タイトル画面
            SC_ST_TITLE, bl {
                //ピクチャを設置する
                @if sceneTimer == 0 bl {
                    @pic.show[PIC_TITLE + 0] PATH_TITLE .pos(REF_X, REF_Y) .topLeft .cell(1) titlePicCmd
                    @pic.show[PIC_TITLE + 1] PATH_TITLE .pos(REF_X, REF_Y) .topLeft .cell(2) titlePicCmd
                    @pic.show[PIC_TITLE + 2] PATH_TITLE .pos(REF_X, REF_Y) .topLeft .cell(3) titlePicCmd
                    //スコアを表示する
                    bitOn(triggerFlg, TR_BIT_SCORE)
                    //BGMを止める
                    stopBGM(0)
                }

                //雲が上下する
                fA = sin(sceneTimer * 2, 1, 3)
                V2_set(ax,
                    REF_X,
                    REF_Y + fA + 3,
                )

                @pic.move[PIC_TITLE + 1] .pos(ax, ay) .topLeft .time(2)
                //決定キーか上を押すと開始する
                @if `INPUT_DECISION bl {
                    _changeSceneState(SC_ST_START)

                    //変数初期化
                    assignVarUsingDeclared(initHead, varFoot, 0)

                    score = 0
                    updateHighScore = FALSE
                    stageCount = 0
                    stageLap = 0

                    lineState = LI_ST_DELETE
                    bitOn(triggerFlg, TR_BIT_INIT_PIC)

                    _fadeIn()

                    @se.play "fc_coin1" .opt(90, 80, 50)
                }
            } ] )

            //----------------------------
            //ゲームシーン中の処理
            @if IN_GAME bl {
                //----------------------------
                //プレイヤー
                bl {
                    //時間
                    plTimer += 1

                    //ライフが尽きた
                    @if plState == PL_ST_NONE bl {
                        //処理は下に記述する
                    } .else bl {
                        //髪の毛の座標を更新する
                        V2_copy(plEffX_2, plEffX_1)
                        V2_copy(plEffX_1, plX)
                        
                        //移動量適用
                        V2_asAdd(plX, plVx)
                        V2_asAdd(plX, plSx)
                        V2_set(plSx, 0, 0)

                        //落下
                        plVy += PL_GRAVITY
                        plVy = clamp(plVy, -1 * PL_MAX_VY, PL_MAX_VY)
                        //地面
                        @if `plY + plVy + SML_SPR_SIZE / 2 * UNIT_POS > GROUND_Y * UNIT_POS bl {
                            bitOn(plBit, CH_BIT_GROUND)
                            plY = (GROUND_Y - SML_SPR_SIZE / 2) * UNIT_POS 
                            plVy = 0
                        }
                        //左右移動
                        @if plState != PL_ST_DAMAGE bl {
                            fA = (plBit & CH_BIT_LOCK) ? (0) : (iptX)
                            plVx = fA * PL_WALK_VX
                            //方向転換
                            @if fA < 0 bl {
                                bitOn(plBit, CH_BIT_HREV)
                            } .elif fA > 0 bl {
                                bitOff(plBit, CH_BIT_HREV)
                            }
                        }
                        //ジャンプ
                        //上昇時のみ岩の速度が加算される
                        @if plState == PL_ST_GROUND bl {
                            fA = (plBit & CH_BIT_LOCK) ? (0) : (iptDec == 1 || iptY < 0)
                            @if `fA bl {
                                bitOff(plBit, CH_BIT_GROUND)
                                plVy = min(plVy, 0)
                                plVy += -1 * PL_JUMP_VY
                                @se.play "fc_jump1" .opt(70, 110, 50)
                            }
                        //急降下
                        } .else bl {
                            //fA = (plBit & CH_BIT_LOCK) ? (0) : (iptY > 0)
                            //@if `fA && plVy < PL_MAX_VY bl {
                            //    plVy = PL_MAX_VY
                            //}
                        }

                        //座標拘束
                        V2_clampPointInsideRect2(plX,
                            SML_SPR_SIZE / 2 * UNIT_POS,
                            SML_SPR_SIZE / 2 * UNIT_POS,
                            (SCREEN_WIDTH  - SML_SPR_SIZE / 2) * UNIT_POS,
                            (SCREEN_HEIGHT - SML_SPR_SIZE / 2) * UNIT_POS
                        )
                        //無敵時間
                        @if plInv > 0 bl {
                            plInv -= 1
                        }
                        //ライフ判定
                        @if plLife <= 0 bl {
                            _changePlayerState(PL_ST_NONE)

                            //パーティクル
                            @loop 8 .dst(iB) bl {
                                ang = iB * 45
                                _getParticlePtr(pB, particleIdx)
                                _initParticle(pB, bl {
                                    $cell = 17
                                    $timer = -1
                                    $x = plX + cos(ang, 1, 4 * UNIT_POS)
                                    $y = plY + sin(ang, 1, 4 * UNIT_POS)
                                    $vx = cos(ang, 1, 10)
                                    $vy = sin(ang, 1, 10)
                                } )
                                _nextParticle()
                            }

                            @se.play "fc_punch1" .opt(80, 100, 50)
                        }
                    }
                    pseudoSwitchState(plState,
                    //地上
                    [PL_ST_GROUND, bl {
                        //立ち
                        @if plVx == 0 bl {
                            cell = 1
                        //歩き
                        } .else bl {
                            easyAnimation(cell, TRUE, 1, 2, plTimer, 4)
                        }
                        @if `!(plBit & CH_BIT_GROUND) bl {
                            _changePlayerState(PL_ST_AIR)
                        }
                    },
                    //空中
                    PL_ST_AIR, bl {
                        cell = 1
                        @if `plBit & CH_BIT_GROUND bl {
                            _changePlayerState(PL_ST_GROUND)
                            @se.play "fc_ground1" .opt(100, 120, 50)
                        }
                    },
                    //ダメージ
                    PL_ST_DAMAGE, bl {
                        cell = 2
                        //地面に落ちると硬直も解除される
                        @if `(plBit & CH_BIT_GROUND) || plTimer > PL_DAMAGE_TIME_2 bl {
                            _changePlayerState(PL_ST_AIR)
                        }
                    },
                    //粉砕
                    PL_ST_NONE, bl {
                        cell = 0
                        //ゲーム進行と重なった場合、復帰できるようにする
                        @if plLife > 0 bl {
                            _changePlayerState(PL_ST_AIR)
                        }
                    } ] )
                    //フラグ初期化
                    bitOff(plBit, CH_BIT_GROUND)
                    //ピクチャ
                    fA = ((plInv > 0 && plInv % 4 < 2) || cell == 0) ? 100 : 0//透明度
                    V2_set(ax,
                        REF_X + plX / UNIT_POS,
                        REF_Y + plY / UNIT_POS
                    )
                    pid = PIC_PLAYER + 2
                    @if `plBit & CH_BIT_HREV bl {
                        @pic.show[pid] .pos(ax,ay) .center .trans(fA) .cell(cell) .hrev charaPicCmd
                    } .else bl {
                        @pic.show[pid] .pos(ax,ay) .center .trans(fA) .cell(cell) charaPicCmd
                    }
                    //髪の毛1
                    V2_set(ax,
                        REF_X + plEffX_1 / UNIT_POS,
                        REF_Y + plEffY_1 / UNIT_POS
                    )
                    @pic.show[PIC_PLAYER + 1] .pos(ax,ay) .center .trans(fA) .cell(3) charaPicCmd
                    //髪の毛2
                    V2_set(ax,
                        REF_X + plEffX_2 / UNIT_POS,
                        REF_Y + plEffY_2 / UNIT_POS
                    )
                    @pic.show[PIC_PLAYER + 0] .pos(ax,ay) .center .trans(fA) .cell(4) charaPicCmd
                }
                //----------------------------
                //敵
                @loop MAX_ENEMY .dst(iA) bl {
                    _getEnemyPtr(pA, iA)
                    //状態
                    state = v[pA + ME_STATE]
                    @if state <= EN_ST_NONE bl {
                        @continue
                    }
                    //時間
                    v[pA + MS_TIMER] += 1
                    timer = v[pA + MS_TIMER]
                    //セル番号
                    cell = 0
                    //タイプごとに分岐する
                    type = v[pA + ME_TYPE]
                    pseudoSwitchState(type,
                    //反射 p1:角度
                    [EN_TYPE_REFLECT, bl {
                        pseudoSwitchState(state,
                        [EN_ST_ACTIVE, bl {
                            easyAnimation(cell, TRUE, 1, 8, timer, 2)
                            //移動
                            ang = v[pA + ME_PARAM_1]
                            rad = EN_REF_SPEED + ((stageLap >= MAX_LAP) ? (EN_SPEED_UP) : (0))
                            v[pA + ME_X] += cos(ang, 1, rad)
                            v[pA + ME_Y] += sin(ang, 1, rad)
                            //壁に反射する
                            @if `v[pA + ME_X] + MID_SPR_SIZE / 2 * UNIT_POS > SCREEN_WIDTH * UNIT_POS ||
                                v[pA + ME_X] - MID_SPR_SIZE / 2 * UNIT_POS < 0 bl {
                                rad = rnd(-EN_REF_RND, EN_REF_RND)
                                v[pA + ME_PARAM_1] = (180 - ang + rad + 360 * 2) % 360
                            }
                            @if `v[pA + ME_Y] + MID_SPR_SIZE / 2 * UNIT_POS > GROUND_Y * UNIT_POS ||
                                v[pA + ME_Y] - MID_SPR_SIZE / 2 * UNIT_POS < 0 bl {
                                rad = rnd(-EN_REF_RND, EN_REF_RND)
                                v[pA + ME_PARAM_1] = (-ang + rad + 360 * 2) % 360
                            }
                        },
                        EN_ST_INIT, bl {
                            cell = 29
                            @if sceneState == SC_ST_GAME bl {
                                _changeEnemyState(pA, EN_ST_ACTIVE)
                                v[pA + ME_PARAM_1] = rnd(270 - 45, 270 + 45)
                            }
                        } ] )
                    },
                    //反時計周りに回る p1:角度
                    EN_TYPE_LOOP, bl {
                        pseudoSwitchState(state,
                        [EN_ST_ACTIVE, bl {
                        easyAnimation(cell, TRUE, 16, 9, timer, 2)
                            //移動
                            ang = v[pA + ME_PARAM_1]
                            rad = EN_LOOP_SPEED + ((stageLap >= MAX_LAP) ? (EN_SPEED_UP) : (0))
                            v[pA + ME_X] += cos(ang, 1, rad)
                            v[pA + ME_Y] += sin(ang, 1, rad)
                            //壁に反射する
                            @if `v[pA + ME_X] + MID_SPR_SIZE / 2 * UNIT_POS > SCREEN_WIDTH * UNIT_POS bl {
                                ang = 90
                            }
                            @if `v[pA + ME_X] - MID_SPR_SIZE / 2 * UNIT_POS < 0 bl {
                                ang = 270
                            }
                            @if `v[pA + ME_Y] + MID_SPR_SIZE / 2 * UNIT_POS > GROUND_Y * UNIT_POS bl {
                                ang = 180
                            }
                            @if `v[pA + ME_Y] - MID_SPR_SIZE / 2 * UNIT_POS < 0 bl {
                                ang = 0
                            }
                            v[pA + ME_PARAM_1] = ang
                        },
                        EN_ST_INIT, bl {
                            cell = 30
                            @if sceneState == SC_ST_GAME bl {
                                _changeEnemyState(pA, EN_ST_ACTIVE)
                                v[pA + ME_PARAM_1] = [270 + 60, 270 - 60][iA % 2]
                            }
                        } ] )
                    },
                    //ゆっくりと近づく p1:角度
                    EN_TYPE_CHASE, bl {
                        pseudoSwitchState(state,
                        [EN_ST_ACTIVE, bl {
                            easyAnimation(cell, TRUE, 17, 24, timer, 2)
                            //移動量
                            ang = v[pA + ME_PARAM_1]
                            rad = EN_CHASE_SPEED + ((stageLap >= MAX_LAP) ? (EN_SPEED_UP) : (0))
                            V2_set(ax,
                                cos(ang, 1, rad),
                                sin(ang, 1, rad)
                            )
                            //移動
                            v[pA + ME_X] += ax
                            v[pA + ME_Y] += ay
                            //方向を変える
                            V2_set(bx,
                                plX - v[pA + ME_X],
                                plY - v[pA + ME_Y]
                            )
                            fA = atan2(by, bx, 1)
                            fB = ax * sin(fA, 1, UNIT_POS) - ay * cos(fA, 1, UNIT_POS)
                            ang += (fB > 0 ? 1 : -1) * EN_CHASE_ROTATE
                            v[pA + ME_PARAM_1] = (ang + 360) % 360
                        },
                        EN_ST_INIT, bl {
                            cell = 31
                            @if sceneState == SC_ST_GAME bl {
                                _changeEnemyState(pA, EN_ST_ACTIVE)
                                v[pA + ME_PARAM_1] = 270
                            }
                        } ] )
                    },
                    //上空を左右に移動し、岩が当たると墜落する p1:向き
                    EN_TYPE_UFO, bl {
                        pseudoSwitchState(state,
                        [EN_ST_ACTIVE, bl {
                            easyAnimation(cell, TRUE, 25, 27, timer, 4)
                            //移動
                            //fA:速度
                            fA = (v[pA + ME_PARAM_1] == 0 ? 1: -1) * EN_UFO_SPEED
                            v[pA + ME_X] += fA
                            //画面端で反射する
                            @if timer < EN_UFO_TIMER bl {
                                @if `v[pA + ME_X] > (SCREEN_WIDTH - MID_SPR_SIZE / 2) * UNIT_POS bl {
                                    v[pA + ME_PARAM_1] = 180
                                } .elif `v[pA + ME_X] < (MID_SPR_SIZE / 2) * UNIT_POS bl {
                                    v[pA + ME_PARAM_1] = 0
                                }
                            //一定時間経つと画面外に消えていく
                            } .else bl {
                                @if `v[pA + ME_X] > (SCREEN_WIDTH + MID_SPR_SIZE / 2) * UNIT_POS ||
                                     v[pA + ME_X] < (-MID_SPR_SIZE / 2) * UNIT_POS bl {
                                    _changeEnemyState(pA, EN_ST_DELETE)
                                }
                            }
                            //乗れる
                            V2_set(ax,
                                plX - v[pA + ME_X],
                                plY - v[pA + ME_Y] + SML_SPR_SIZE * UNIT_POS
                            )
                            @if `abs(ax) <= SML_SPR_SIZE * UNIT_POS bl {                            
                                @if `ay <= EN_UFO_THICK && ay + plVy + plSy >= -EN_UFO_THICK bl {
                                    _putPlayerOnLift(v[pA + ME_Y] - SML_SPR_SIZE * UNIT_POS, fA, 0)
                                }
                            }
                            //岩との当たり判定
                            @loop MAX_ROCK .dst(iB) bl {
                                _getRockPtr(pB, iB)
                                @if `v[pB + MR_STATE] <= RO_ST_NONE bl {
                                    @continue
                                }
                                @if `abs(v[pA + ME_X] - v[pB + MR_X]) < SML_SPR_SIZE * UNIT_POS &&
                                     abs(v[pA + ME_Y] - v[pB + MR_Y]) < SML_SPR_SIZE * UNIT_POS bl {
                                    _changeEnemyState(pA, EN_ST_DEFEAT)
                                    //スコア
                                    _addScore(SCORE_UFO, 1, v[pA + ME_X] / UNIT_POS, v[pA + ME_Y] / UNIT_POS - 16)
                                    //効果音
                                    @se.play "fc_explosion1" .opt(80, 100, 50)
                                    @break
                                }
                            }
                        },
                        EN_ST_DEFEAT, bl {
                            cell = timer % 4 < 2 ? 28 : 0
                            //落ちる
                            v[pA + ME_Y] += 1
                            //爆炎
                            @if `!(timer % 8) bl {
                                _getParticlePtr(pB, particleIdx)
                                _initParticle(pB, bl {
                                    $cell = 13
                                    $timer = -1
                                    $x = v[pA + ME_X] + rnd(-6, 6) * UNIT_POS
                                    $y = v[pA + ME_Y] + rnd(-6, 6) * UNIT_POS
                                    $vy = -1 * UNIT_POS
                                } )
                                _nextParticle()
                            }
                            //消える
                            @if timer > 90 bl {
                                _changeEnemyState(pA, EN_ST_DELETE)
                            }
                        },
                        EN_ST_INIT, bl {
                            cell = 0
                            @if sceneState == SC_ST_GAME bl {
                                _changeEnemyState(pA, EN_ST_ACTIVE)

                                //左右端に置く
                                //高さは固定
                                fA = rnd(0, 1)
                                v[pA + ME_PARAM_1] = [0, 180][fA]
                                v[pA + ME_X] = [-SML_SPR_SIZE * UNIT_POS, (SCREEN_WIDTH + SML_SPR_SIZE) * UNIT_POS][fA]
                                v[pA + ME_Y] = UFO_Y * UNIT_POS
                            }
                        } ] )
                    } ] )

                    //共通処理
                    @if `type != EN_TYPE_UFO && state == EN_ST_ACTIVE bl {
                        //位置座標を拘束
                        v[pA + ME_X] = clamp(v[pA + ME_X], MID_SPR_SIZE / 2 * UNIT_POS, (SCREEN_WIDTH - MID_SPR_SIZE / 2) * UNIT_POS)
                        v[pA + ME_Y] = clamp(v[pA + ME_Y], MID_SPR_SIZE / 2 * UNIT_POS, (GROUND_Y - MID_SPR_SIZE / 2) * UNIT_POS)
                        //プレイヤーとの当たり判定
                        //無敵モードだと当たらない
                        @if `plInv <= 0 && !invincibleSwitch bl {
                            V2_set(ax,
                                plX - v[pA + ME_X],
                                plY - v[pA + ME_Y]
                            )
                            @if `abs(ax) < EN_RAD * UNIT_POS &&
                                 abs(ay) < EN_RAD * UNIT_POS bl {
                                fA = ax > 0 ? TRUE : FALSE
                                _damageToPlayer(fA)
                                @se.play "fc_explosion1" .opt(80, 120, 50)
                            }
                        }
                    }
                    //表示位置
                    V2_set(ax,
                        REF_X + v[pA + ME_X] / UNIT_POS,
                        REF_Y + v[pA + ME_Y] / UNIT_POS
                    )
                    //ピクチャ
                    pid = PIC_ENEMY + iA
                    @if state == EN_ST_DELETE bl {
                        _changeEnemyState(pA, EN_ST_NONE)
                        @pic.move[pid] .pos(OUT_RANGE, OUT_RANGE) .trans(100)
                    } .else bl {
                        @pic.show[pid] .pos(ax,ay) .center .cell(cell) midCharaPicCmd
                    }
                }
                //----------------------------
                //星
                @loop MAX_STAR .dst(iA) bl {
                    _getStarPtr(pA, iA)
                    //状態
                    state = v[pA + MS_STATE]
                    @if state <= ST_ST_NONE bl {
                        @continue
                    }
                    //時間
                    v[pA + MS_TIMER] += 1
                    timer = v[pA + MS_TIMER]
                    //表示位置
                    //後でずらすのでここに置く
                    V2_set(ax,
                        REF_X + v[pA + MS_X] / UNIT_POS,
                        REF_Y + v[pA + MS_Y] / UNIT_POS
                    )
                    pseudoSwitchState(state,
                    [ST_ST_WAIT, bl {
                        cell = 9
                        //プレイヤーが触れると発光する
                        @if `abs(plX - v[pA + MS_X]) < SML_SPR_SIZE * UNIT_POS bl {
                            @if `abs(plY - v[pA + MS_Y]) < SML_SPR_SIZE * UNIT_POS bl {
                                _changeStarState(pA, ST_ST_ACTIVE)
                                cell = 10
                                //ノルマ
                                starCount -= 1
                                //スコア
                                _addScore(SCORE_STAR * comboCount, 1, v[pA + MS_X] / UNIT_POS, v[pA + MS_Y] / UNIT_POS - 16)
                                //演出
                                @se.play "fc_coin1" .opt(90, 100, 50)
                                //パーティクル
                                @loop 2 .dst(iB) bl {
                                    ang = iB * 180 + rnd(-60, 60)
                                    rad = rnd(4, 8)
                                    _getParticlePtr(pB, particleIdx)
                                    _initParticle(pB, bl {
                                        $cell = 1
                                        $timer = -1
                                        $x = v[pA + MS_X] + cos(ang, 1, rad * UNIT_POS)
                                        $y = v[pA + MS_Y] + sin(ang, 1, rad * UNIT_POS)
                                        $vy = -1 * UNIT_POS / 5
                                    } )
                                    _nextParticle()
                                }
                            }
                        }
                    },
                    ST_ST_ACTIVE, bl {
                        easyAnimation(cell, FALSE, 10, 13, timer, 4)
                        //微妙に上下に揺れる
                        ay += sin(sceneTimer * 4, 1, 2)
                        //時間が経つとランダムに発光する
                        @if `timer > 120 && timer % 60 == 0 && rnd(0, 99) < 20 bl {
                            v[pA + MS_TIMER] = 0
                        }
                    },
                    ST_ST_INIT, bl {
                        cell = 9
                        @if timer <= 16 bl {
                            ay = lerp(REF_Y - 8, ay, timer, 16)
                        //起動する
                        } .elif sceneState == SC_ST_GAME bl {
                            _changeStarState(pA, ST_ST_WAIT)
                        }
                    } ] )
                    //ピクチャ
                    pid = PIC_STAR + iA
                    @if state == ST_ST_DELETE bl {
                        _changeStarState(pA, ST_ST_NONE)
                        @pic.move[pid] .pos(OUT_RANGE, OUT_RANGE) .trans(100)
                    } .else bl {
                        @pic.show[pid] .pos(ax,ay) .center .cell(cell) charaPicCmd
                    }
                }
                //----------------------------
                //岩
                @loop MAX_ROCK .dst(iA) bl {
                    _getRockPtr(pA, iA)
                    //状態
                    state = v[pA + MR_STATE]
                    @if state <= RO_ST_NONE bl {
                        @continue
                    }
                    //時間
                    v[pA + MR_TIMER] += 1
                    timer = v[pA + MR_TIMER]
                    
                    pseudoSwitchState(state,
                    //待機
                    [RO_ST_GROUND, bl {
                        cell = 14
                        //他の岩と衝突していると横に移動する
                        @if `!(timer % 4) bl {
                            fA = MAX_ROCK - iA
                            @loop fA .dst(iB) bl {
                                iB += iA
                                _getRockPtr(pB, iB)
                                @if `v[pB + MR_STATE] != RO_ST_GROUND bl {
                                    @continue
                                }
                                ax = v[pB + MR_X] - v[pA + MR_X]
                                @if `abs(ax) < SML_SPR_SIZE * UNIT_POS bl {
                                    ax = ax > 0 ? 1 : -1
                                    v[pA + MR_X] -= ax * UNIT_POS
                                    v[pB + MR_X] += ax * UNIT_POS 
                                }
                            }
                        }
                    },
                    //落下
                    RO_ST_FALL, bl {
                        cell = 15
                        //落下
                        @if `v[pA + MR_Y] + v[pA + MR_VY] + SML_SPR_SIZE / 2 * UNIT_POS >= GROUND_Y * UNIT_POS bl {
                            _changeRockState(pA, RO_ST_GROUND)
                            v[pA + MR_Y] = (GROUND_Y - SML_SPR_SIZE / 2) * UNIT_POS
                            v[pA + MR_VX] = 0
                            v[pA + MR_VY] = 0
                        }
                        //パーティクル
                        @if `!(timer % 8) bl {
                            ang = -90 + rnd(-30, 30)
                            _getParticlePtr(pB, particleIdx)
                            _initParticle(pB, bl {
                                $cell = 9
                                $timer = -1
                                $x = v[pA + MR_X]
                                $y = v[pA + MR_Y]
                                $vx = cos(ang, 1, 4)
                                $vy = sin(ang, 1, 4)
                            } )
                            _nextParticle()
                        }
                    },
                    //上昇
                    RO_ST_UP, bl {
                        cell = 16
                        //上に到着すると落下する
                        @if `v[pA + MR_Y] < RO_CEIL * UNIT_POS bl {
                            _changeRockState(pA, RO_ST_FALL)
                            v[pA + MR_VY] = RO_VY
                        }
                        //パーティクル
                        @if `!(timer % 6) bl {
                            ang = 90 - 45 * v[pA + MR_VX] + rnd(-30, 30)
                            rad = rnd(2, 6)
                            _getParticlePtr(pB, particleIdx)
                            _initParticle(pB, bl {
                                $cell = 5
                                $timer = -1
                                $x = v[pA + MR_X]
                                $y = v[pA + MR_Y]
                                $vx = cos(ang, 1, rad)
                                $vy = sin(ang, 1, rad)
                            } )
                            _nextParticle()
                        }
                    } ] )

                    //移動量を適用する
                    v[pA + MR_X] += v[pA + MR_VX]
                    v[pA + MR_Y] += v[pA + MR_VY]
                    //横座標を拘束
                    v[pA + MR_X] = clamp(v[pA + MR_X], SML_SPR_SIZE / 2 * UNIT_POS, (SCREEN_WIDTH - SML_SPR_SIZE / 2) * UNIT_POS )
                    //反射判定
                    ang = v[pA + MR_VX]
                    ipt = v[pA + MR_X]
                    @if `(ang > 0 && ipt + SML_SPR_SIZE / 2 * UNIT_POS >= SCREEN_WIDTH * UNIT_POS) ||
                         (ang < 0 && ipt - SML_SPR_SIZE / 2 * UNIT_POS <= 0) bl {
                        v[pA + MR_VX] *= -1
                    }
                    //プレイヤーは岩に乗れる
                    @if `plVy + plSy >= v[pA + MR_VY] bl {
                        V2_set(bx,
                            plX - v[pA + MR_X],
                            plY - v[pA + MR_Y] + SML_SPR_SIZE * UNIT_POS
                        )
                        @if `abs(bx) <= SML_SPR_SIZE * UNIT_POS bl {                            
                            @if `by <= RO_THICK && by + plVy + plSy - v[pA + MR_VY] >= -RO_THICK bl {
                                //地面に落ちている状態で乗ると起動する
                                //操作がロックされていると無効になる
                                @if `state == RO_ST_GROUND && !(plBit & CH_BIT_LOCK) bl {
                                    _changeRockState(pA, RO_ST_UP)
                                    v[pA + MR_VX] = ((plBit & CH_BIT_HREV) ? -1 : 1) * RO_VX
                                    v[pA + MR_VY] = -1 * RO_VY
                                    @se.play "fc_jump1" .opt(70, 150, 50)
                                }
                                _putPlayerOnLift(v[pA + MR_Y] - SML_SPR_SIZE * UNIT_POS, v[pA + MR_VX], v[pA + MR_VY])
                            }
                        }
                    }
                    //表示位置
                    V2_set(ax,
                        REF_X + v[pA + MR_X] / UNIT_POS,
                        REF_Y + v[pA + MR_Y] / UNIT_POS
                    )
                    //ピクチャ
                    pid = PIC_ROCK + iA
                    @if state == RO_ST_DELETE bl {                    
                        _changeRockState(pA, RO_ST_NONE)
                        @pic.move[pid] .pos(OUT_RANGE, OUT_RANGE) .trans(100)
                    } .else bl {
                        @pic.show[pid] .pos(ax,ay) .center .cell(cell) charaPicCmd
                    }
                }
                //----------------------------
                //パーティクル
                @loop MAX_PARTICLE .dst(iA) bl {
                    _getParticlePtr(pA, iA)
                    //セル番号で判定する
                    cell = v[pA + MP_CELL]
                    @if `cell <= 0 bl {
                        @continue
                    }
                    //時間
                    v[pA + MP_TIMER] += 1
                    timer = v[pA + MP_TIMER]
                    //消滅判定
                    @if timer >= PA_FRAME * PA_INTERVAL bl {
                        cell = 0
                    //アニメーション
                    } .else bl {
                        cell += timer / PA_INTERVAL
                    }
                    //移動量
                    v[pA + MP_X] += v[pA + MP_VX]
                    v[pA + MP_Y] += v[pA + MP_VY]
                    //表示位置
                    V2_set(ax,
                        REF_X + v[pA + MP_X] / UNIT_POS,
                        REF_Y + v[pA + MP_Y] / UNIT_POS
                    )
                    //ピクチャ
                    pid = PIC_PARTICLE + iA
                    @if cell <= 0 bl {
                        v[pA + MP_CELL] = 0
                        @pic.move[pid] .pos(OUT_RANGE, OUT_RANGE) .trans(100)
                    } .else bl {
                        @pic.show[pid] .pos(ax,ay) .center .cell(cell) partPicCmd
                    }
                }

                //----------------------------
                //コンボ
                @if comboTimer > 0 bl {
                    comboTimer -= 1
                    @if comboTimer <= 0 bl {
                        comboCount = 0
                        //スコア表示を消す
                        @loop ADD_SCORE_DIGIT .dst(iA) bl {
                            pid = PIC_ADD_SCORE + iA
                            hidePicture(pid)
                        }
                    }
                }

                //----------------------------
                //背景スクロール
                bgScroll += 2
                bgScroll %= CLOUD_WIDTH * UNIT_POS
                fA = bgScroll
                fB = (bgScroll * 2) % (CLOUD_WIDTH * UNIT_POS)
                @loop CLOUD_NUMER .dst(iA) bl {
                    pid = PIC_BACK_CLOUD + iA
                    V2_set(ax,
                        REF_X - CLOUD_WIDTH + (fA / UNIT_POS + CLOUD_WIDTH * iA),
                        REF_Y + SCREEN_HEIGHT - 4
                    )
                    @pic.move[pid] .pos(ax, ay) .bottomLeft
                }
                @loop CLOUD_NUMER .dst(iA) bl {
                    pid = PIC_FRONT_CLOUD + iA
                    V2_set(ax,
                        REF_X - CLOUD_WIDTH + (fB / UNIT_POS + CLOUD_WIDTH * iA),
                        REF_Y + SCREEN_HEIGHT
                    )
                    @pic.move[pid] .pos(ax, ay) .bottomLeft
                }
            }

            //----------------------------
            //文字列
            @if lineState > LI_ST_NONE bl {
                //削除
                @if lineState == LI_ST_DELETE bl {
                    @loop lineLen .dst(pid) bl {
                        pid += PIC_STRING
                        hidePicture(pid)
                    }
                    lineState = LI_ST_NONE
                    lineLen = 0
                //何もしない
                } .elif lineState == LI_ST_FIX bl {

                //指定した位置に置く
                } .elif lineState == LI_ST_PUT bl {
                    lineState = LI_ST_FIX
                    @loop lineLen .dst(iA) bl {
                        pid = PIC_STRING + iA
                        V2_set(ax,
                            REF_X + lineX + iA * MID_FONT_WIDTH - lineLen * MID_FONT_WIDTH / 2 + MID_FONT_WIDTH / 2,
                            REF_Y + lineY
                        )
                        @pic.move[pid] .pos(ax, ay) .center
                    }
                //ウェーブ
                } .elif lineState == LI_ST_EASING bl {
                    @loop lineLen .dst(iA) bl {
                        //時間差
                        @if `sceneTimer < iA * 4 bl {
                            @break
                        }
                        pid = PIC_STRING + iA
                        V2_set(ax,
                            REF_X + lineX + iA * MID_FONT_WIDTH - lineLen * MID_FONT_WIDTH / 2 + MID_FONT_WIDTH / 2,
                            REF_Y + lineY + cos(sceneTimer * 4 + 30 * iA, 1, 7) / 2
                        )
                        @pic.move[pid] .pos(ax, ay) .center .time(2)
                    }
                }
            }
            
            //----------------------------
            //フェードイン
            @if fadeTimer > 0 bl {
                fadeTimer -= 1
                @if fadeTimer <= 0 bl {
                    hidePicture(PIC_FADE)
                } .else bl {
                    fA = lerp(100, 0, fadeTimer, FADE_TIME)
                    V2_set(ax,
                        REF_X + SCREEN_WIDTH  / 2,
                        REF_Y + SCREEN_HEIGHT / 2
                    )
                    V2_set(bx,
                        lerp(100 * SCREEN_WIDTH  / 8, 0, fA, 100),
                        lerp(100 * SCREEN_HEIGHT / 8, 0, fA, 100)
                    )
                    @pic.show[PIC_FADE] .pos(ax, ay) .center .scale2(bx, by) .cell(1) fadePicCmd
                }
            }

            //----------------------------
            triggerSwitchState(triggerFlg,
            [TR_BIT_INIT_PIC, bl {
                //タイトル
                @loop 3 .dst(pid) bl {
                    pid += PIC_TITLE
                    hidePicture(pid)
                }
                //背景
                @pic.show[PIC_BACK] PATH_BACK .pos(REF_X, REF_Y) .topLeft basePicCmd
                //雲
                @loop CLOUD_NUMER .dst(pid) bl {
                    pid += PIC_BACK_CLOUD
                    @pic.show[pid] .pos(OUT_RANGE, OUT_RANGE) .topLeft .cell(1) cloudPicCmd
                }
                @loop CLOUD_NUMER .dst(pid) bl {
                    pid += PIC_FRONT_CLOUD
                    @pic.show[pid] .pos(OUT_RANGE, OUT_RANGE) .topLeft .cell(2) cloudPicCmd
                }
                //ステージ番号
                @loop STAGE_NUM_PIC .dst(pid) bl {
                    pid += PIC_STAGE
                    hidePicture(pid)
                }
                //スコア
                @loop SCORE_DIGIT .dst(pid) bl {
                    pid += PIC_SCORE
                    hidePicture(pid)
                }
                //獲得スコア
                @loop ADD_SCORE_DIGIT .dst(pid) bl {
                    pid += PIC_ADD_SCORE
                    hidePicture(pid)
                }
                //ライフ
                hidePicture(PIC_LIFE)
                //星
                @loop MAX_STAR .dst(pid) bl {
                    pid += PIC_STAR
                    hidePicture(pid)
                }
                //岩
                @loop MAX_ROCK .dst(pid) bl {
                    pid += PIC_ROCK
                    hidePicture(pid)
                }
                //敵
                @loop MAX_ENEMY .dst(pid) bl {
                    pid += PIC_ENEMY
                    hidePicture(pid)
                }
                //パーティクル
                @loop MAX_PARTICLE .dst(pid) bl {
                    pid += PIC_PARTICLE
                    hidePicture(pid)
                }
            },
            TR_BIT_SCORE, bl {
                _showCounter(score, PIC_SCORE, SCORE_DIGIT, MID_FONT_WIDTH, REF_X + SCORE_X, REF_Y + SCORE_Y)
                //ハイスコアの更新判定
                @if score > lightupScore bl {
                    //更新した瞬間に音が鳴る
                    //ハイスコアが0だった場合は除く
                    @if `lightupScore > 0 && !updateHighScore bl {
                        @se.play "itemget2" .opt(80, 130, 50)
                    }
                    updateHighScore = TRUE
                    lightupScore = score
                }
            },
            TR_BIT_ADD_SCORE, bl {
                fA = 0
                @loop ADD_SCORE_DIGIT .dst(iA) bl {
                    $NUM = pow(10, iA)
                    fA += (addScore / $NUM) > 0 ? 1 : 0
                }
                @if fA > 0 bl {
                    V2_set(ax,
                        REF_X + addScoreX + fA * SML_FONT_WIDTH / 2,
                        REF_Y + addScoreY
                    )
                    @loop ADD_SCORE_DIGIT .dst(iA) bl {
                        pid = PIC_ADD_SCORE + iA
                        $NUM = pow(10, iA)
                        cell = (iA >= fA) ? (0) : (1 + addScore / $NUM % 10)
                        @pic.show[pid] .pos(ax, ay) .topRight .cell(cell) smallNumberPicCmd
                        @pic.move[pid] .relative .pos(0, -8) .scale(0) .trans(0) .time(10)
                        ax -= SML_FONT_WIDTH
                    }
                    //スコア加算
                    score = min(score + addScore, MAX_SCORE)
                    addScore = 0
                    bitOn(triggerFlg, TR_BIT_SCORE)
                }
            },
            TR_BIT_LIFE, bl {
                cell = 1 + plLife
                @pic.show[PIC_LIFE] .pos(REF_X + LIFE_X, REF_Y + LIFE_Y) .center .scale(200) .cell(cell) lifePicCmd
                @pic.move[PIC_LIFE] .pos(REF_X + LIFE_X, REF_Y + LIFE_Y) .center .scale(100) .time(4)
            },
            TR_BIT_STAGE, bl {
                ipt = stageCount
                _showCounter(ipt, PIC_STAGE, STAGE_NUM_DIGIT, MID_FONT_WIDTH, REF_X + STAGE_NUM_X, REF_Y + STAGE_NUM_Y)
                // /
                @pic.show[PIC_STAGE + 2] .pos(REF_X + STAGE_NUM_X + 8 * 0, REF_Y + STAGE_NUM_Y) .topLeft .cell(_SL) fontPicCmd
                // 最大値
                @pic.show[PIC_STAGE + 3] .pos(REF_X + STAGE_NUM_X + 8 * 1, REF_Y + STAGE_NUM_Y) .topLeft .cell(MAX_STAGE / 10 + _0) fontPicCmd
                @pic.show[PIC_STAGE + 4] .pos(REF_X + STAGE_NUM_X + 8 * 2, REF_Y + STAGE_NUM_Y) .topLeft .cell(MAX_STAGE % 10 + _0) fontPicCmd
            } ] )
        }
    }

    //------------------------------------------------------------------------------------
    //終了する
    @label.set "gameEnd"
    bl {
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, TS_MINIGAME, NUM_OF_STR)
        restoreBGM()
        @scr.tint .rgbs(100, 100, 100, 100) .time(1) .wait
    }
}