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


cev[CEV_GOMEZ_TOWER] .name("mg_ゴメスタワー") {

    def {
        NUM_OF_VAR = 256
        NUM_OF_STR = 6
        NUM_OF_PIC = 128

        BASE_LAYER = 6

        PATH_PORTRAIT = "gt\po"
        PATH_SINGLE   = "gt\ed"
        PATH_MAPDATA  = "gt\ma_"
        PATH_MAPTILE  = "gt\ti"
        PATH_BG       = "gt\bg"
        PATH_CHARA    = "gt\ch"
        PATH_NPC      = "gt\np"
        PATH_EFFECT   = "gt\ef"
        PATH_TUTORIAL = "gt\tu"

        PIC_HEAD    = 1
        PIC_MAPDATA = 2
        PIC_BACK    = 3//+0_+3
        PIC_TILE    = 10//+0_+47
        PIC_NPC     = 60//+0_+7
        PIC_CHARA   = 70//+0_+7
        PIC_EFFECT  = 80//+0_+3
        PIC_SINGLE   = 90
        PIC_TUTORIAL = 91
        PIC_PORTRAIT = 101//+0_+1
        PIC_MESSAGE  = 103
        PIC_TIMER    = 104

        //
        GT_ACHIEVE_COUNT = UNIT_FPS * 60 * 10//10分

        //シーン
        SCENE_NONE = 0
        SCENE_GAME
        SCENE_ENDING
        
        //イベント
        EVENT_ST_NONE = 0
        EVENT_ST_READ
        EVENT_ST_WAIT
        EVENT_ST_PORTRAIT
        EVENT_ST_MESSAGE
        EVENT_ST_START
        EVENT_ST_GOAL
        EVENT_ST_ENDING
        EVENT_ST_DEFEATED_BOSS

        //マップ
        TILE_SIZE_PX = 48
        MAP_SHOW_NUM_X = 8
        MAP_SHOW_NUM_Y = 6

        //攻撃属性
        ATK_NONE = 0
        ATK_PL_FALL
        ATK_PL_DASH
        ATK_PL_STAMP
        ATK_EN_NORMAL

        //射撃属性
        SHT_NONE = 0
        SHT_TO_PL

        //----------------------------
        //キャラ
        CH_NUM = 6

        //キャラIDの振り分け
        CH_ID_PLAYER = 0
        CH_ID_ALEX
        CH_ID_BOSS

        CH_ID_EV_BOSS = 0
        CH_ID_EV_PLAYER
        CH_ID_EV_ALEX

        MC_TYPE = 0
        MC_STATE
        MC_TIMER
        MC_ID
        MC_BIT
        MC_CELL
        MC_PM_1
        MC_PM_2
        MC_X
        MC_Y
        MC_VX
        MC_VY
        SIZE_OF_CH

        //キャラクタータイプ
        CH_TYPE_NONE = 0
        CH_TYPE_PL
        CH_TYPE_EN_1
        CH_TYPE_EN_2
        CH_TYPE_EN_3
        CH_TYPE_EN_4
        CH_TYPE_EN_BOSS_1
        CH_TYPE_EN_BOSS_ATK_1
        CH_TYPE_EN_BOSS_ALEX
        CH_TYPE_EVENT

        //キャラクターのビットフラグ
        CH_BIT_HREV       = 1 << 0
        CH_BIT_SLIP       = 1 << 1
        CH_BIT_WALLRUN    = 1 << 2
        CH_BIT_HIJUMP     = 1 << 3
        CH_BIT_MELT       = 1 << 4
        CH_BIT_SLIDE      = 1 << 5
        CH_BIT_GRAVITY    = 1 << 6
        CH_BIT_SCREEN     = 1 << 7
        CH_BIT_BREAK_H    = 1 << 8
        CH_BIT_BREAK_V    = 1 << 9
        CH_BIT_COLL_MAP   = 1 << 10
        CH_BIT_COLL_L     = 1 << 11
        CH_BIT_COLL_T     = 1 << 12
        CH_BIT_COLL_R     = 1 << 13
        CH_BIT_COLL_B     = 1 << 14
        CH_BIT_COLL_DAM   = 1 << 15
        CH_BIT_CLIFF      = 1 << 16
        CH_BIT_COLL_ATK   = 1 << 17
        CH_BIT_COLL_HEAVY = 1 << 18
        CH_BIT_COLL_STAMP = 1 << 19
        CH_BIT_DIR_PL     = 1 << 20
        CH_BIT_SIGNAL     = 1 << 21

        //キャラクターの状態
        CH_ST_NONE   = 0//状態はビットで表す(0_31)
        CH_ST_DELETE = 1 << 0//消去予約
        CH_ST_INIT   = 1 << 1//登場直後
        CH_ST_ACTIVE = 1 << 2//基本状態

        //プレイヤー
        PL_ST_WALK     = 1 << 3
        PL_ST_LAND     = 1 << 4
        PL_ST_HIJUMP   = 1 << 5
        PL_ST_JUMP     = 1 << 6
        PL_ST_FALL     = 1 << 7
        PL_ST_STAMP    = 1 << 8
        PL_ST_STAMP_EN = 1 << 9
        PL_ST_DASH     = 1 << 10
        PL_ST_DASH_EN  = 1 << 11
        PL_ST_SLIP     = 1 << 12
        PL_ST_WALLRUN  = 1 << 13
        PL_ST_CLIFF    = 1 << 14
        PL_ST_DAMAGE   = 1 << 15
        PL_ST_EVENT    = 1 << 16

        PL_INV_TIMER = 80
        PL_KNOCKBACK_VX = -3
        PL_KNOCKBACK_VY = -4

        //敵
        EN_ST_DEFENSE  = 1 << 3
        EN_ST_DAMAGE   = 1 << 4

        //ボス
        BO_ST_EVENT    = 1 << 5
        BO_ST_ESCAPE   = 1 << 6
        BO_ST_RECOVER  = 1 << 7
        BO_ST_DASH     = 1 << 8
        BO_ST_DASH_EN  = 1 << 9
        BO_ST_METAL    = 1 << 10
        BO_ST_SHOOT    = 1 << 11
        BO_ST_STAMP    = 1 << 12
        BO_ST_STAMP_EN = 1 << 13
        BO_ST_EVENT_CH = 1 << 14

        BOSS_HP = 12
        BOSS_PHASE = 6

        //衝突判定
        CH_COLL_LR = 12//衝突判定はキャラクター共通
        CH_COLL_T  = -41
        CH_COLL_B  = -1
        CH_COLL_C  = -32//崖捕まり用
        
        CH_HIT_LR  = 16//攻撃判定用の衝突判定
        CH_HIT_T   = -40
        CH_HIT_B   = -2

        //重力
        CH_GRAVITY = 4

        //セル番号
        CH_CELL_PL = 1
        CH_CELL_EN_1 = 49
        CH_CELL_EN_2 = 55
        CH_CELL_EN_3 = 59
        CH_CELL_EN_4 = 65
        CH_CELL_EN_BOSS = 73
        CH_CELL_ALEX = 100
        CH_CELL_TUTORIAL = 0
        CH_CELL_CHASE = 0

        //----------------------------
        //NPCキャラクター
        NPC_NUM = 8

        MN_TYPE = 0
        MN_STATE
        MN_TIMER
        MN_BIT
        MN_CELL
        MN_PM_1
        MN_X
        MN_Y
        SIZE_OF_NPC

        NPC_TYPE_NONE = 0
        NPC_TYPE_TUTORIAL
        NPC_TYPE_CHASE
        NPC_TYPE_GATE
        NPC_TYPE_GOAL

        NPC_ST_NONE   = 1 << 0
        NPC_ST_INIT   = 1 << 1
        NPC_ST_WAIT   = 1 << 2
        NPC_ST_ACTIVE = 1 << 3

        NPC_BIT_HREV   = 1 << 0
        NPC_BIT_SCREEN = 1 << 1

        NPC_CELL_TUTORIAL = 57
        NPC_CELL_CHASE = 1
        NPC_CELL_GATE = 63
        NPC_CELL_GOAL = 63

        //----------------------------
        //エフェクト
        EFF_NUM = 4

        ME_TYPE = 0
        ME_TIMER
        ME_CELL
        ME_SCALE//負数にすると左右反転する
        ME_X
        ME_Y
        SIZE_OF_EFF

        EFF_TYPE_NONE = 0
        EFF_TYPE_COMMON
        EFF_TYPE_GATE

        EFF_CELL_GATE = 17

        //----------------------------
        //軌跡
        //y << 16 | x
        //0 < xy < 65535
        TR_NUM = 14
        TR_INTERVAL = 4
        TR_CH_INTERVAL = 2
        TR_CH_OFFSET = 16
        TR_CH_OFFSET_SP = 5

        //----------------------------
        //シーン制御
        SC_BIT_GAME       = 1 << 0
        SC_BIT_SHOW_TIMER = 1 << 1
        SC_BIT_SCR_INIT   = 1 << 2
        SC_BIT_SCR_LOCK   = 1 << 3
        SC_BIT_SCR_SINGLE = 1 << 4
        SC_BIT_SHAKE      = 1 << 5

        //----------------------------
        //タイマー
        TIMER_X = 4
        TIMER_Y = 4

        //----------------------------
        //定数
        OUT_RANGE = -320
        UNIT_POS = 10
        CH_PIC_SIZE = 80
        CH_MAX_SPEED = 16
        PORTRAIT_WIDTH = 192
        MAX_STAGE = 3
        MAX_TIMER = UNIT_FPS * 60 * 59//59分

        SCREEN_OUT_X = 24 * 6
        SCREEN_OUT_Y = 24 * 6

        IN_EVENT = eventState != EVENT_ST_NONE
        FAST_FORWARD_OP = inputS > 0 || inputY > 0
        NEXT_SCENE_OP = inputD == 1 || inputS == 1 || inputY > 0
    }

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

        baseStrPicCmd = {
            .spacing(0, 4)
            .skin ""
            .rgbs(100, 100, 100, 100)
            .chromakey(1)
            .mapLayer(BASE_LAYER)
            .eraseWhenTransfer
            .affectedByTint
            .affectedByFlash
        }

        singlePicCmd = bl {
            PATH_SINGLE
            .topLeft
            .grid(1,1)
            basePicCmd
        }

        portraitPicCmd = bl {
            PATH_PORTRAIT
            .topLeft
            .grid(2,2)
            basePicCmd
        }

        mapDataPicCmd = bl {
            PATH_MAPDATA
            .topLeft
            basePicCmd
        }

        mapTilePicCmd = bl {
            PATH_MAPTILE
            .topLeft
            .grid(4,3)
            basePicCmd
        }

        bgPicCmd = bl {
            PATH_BG
            .topLeft
            .grid(2,2)
            basePicCmd
        }

        charaPicCmd = bl {
            PATH_CHARA
            .bottom
            .grid(12,10)
            basePicCmd
        }

        npcPicCmd = bl {
            PATH_NPC
            .bottom
            .grid(8,8)
            basePicCmd
        }

        effectPicCmd = bl {
            PATH_EFFECT
            .center
            .grid(8,3)
            basePicCmd
        }

        tutorialPicCmd = bl {
            PATH_TUTORIAL
            .top
            .grid(1,3)
            basePicCmd
        }
    }

    defv {
        varHead = TV_MINIGAME

        type
        state
        timer
        bit
        param1
        param2
        scale
        px
        py
        vx
        vy

        tagVx
        accVx
        iptSgn
        collBit

        atkType
        atkState
        atkHw
        atkHh
        atkX
        atkY
        atkedType

        shtChara
        shtType
        shtX
        shtY
        shtVx
        shtVy

        col
        pid
        cell
        sgn

        ftA
        ftB
        iA
        iB
        pA
        pB
        pC
        ax
        ay
        bx
        by
        cx
        cy

        inputX
        inputY
        inputD
        inputS

        eventState
        eventTimer
        eventParam

        damageCnt
        gameTimer
        stageNumber
        sceneBit

        initHead

        scrX
        scrY
        scrOldX
        scrOldY
        scrAddX
        scrAddY
        mapWidth
        mapHeight

        trailIdx
        trailCnt
        trailOffset
        effIndex
        shakeTimer
        stopTimer
        bossHp

        trailHead
        charaHead = __id(trailHead) + TR_NUM
        npcHead = __id(charaHead) + SIZE_OF_CH * CH_NUM
        effHead = __id(npcHead) + SIZE_OF_NPC * NPC_NUM
        varFoot = __id(effHead) + SIZE_OF_EFF * EFF_NUM
    }

    deft {
        strEvents = TS_MINIGAME
        strLine
        strCommand
        strParam
        strMessage
        strTime
    }
    
    commentRangeOfVariables(varFoot, TV_MINIGAME, NUM_OF_VAR, NUM_OF_STR, NUM_OF_PIC)

    //----------------------------
    __fn _changeEventState $state bl {
        v[__id(eventState)..__id(eventTimer)] = [$state, -1]
    }

    //イベントコマンドを追加し、実行する
    __fn _pushEvents $flash $exe $events bl {
        __if $flash == TRUE bl {
            strEvents .asg($events .extract)
        } .else bl {
            strEvents .asg(__str($events, NEWLINE, "\", strEvents) .extract)
        }
        __if $exe == TRUE bl {
            v[__id(eventState)..__id(eventTimer)] = [EVENT_ST_READ, -1]
        }
    }

    //地形用ピクチャからピクセルを取得する
    //範囲外である場合は0が入力される
    __fn _getPixelFromMap $dvPixel $x $y bl {
        v[__id($dvPixel)] = 0
        @if `between($x, 0, mapWidth - 1) && between($y, 0, mapHeight - 1) bl {
            @pic.getInfo [PIC_MAPDATA] .pixel($x, $y, 1, 1) .dst($dvPixel) .ignoreA .static
        }
    }

    //ピクセルからセル番号を取得する
    __fn _getMapTilePattern $dvPixel $pix bl {
        v[__id($dvPixel)] = ($pix) & 0xff
    }

    //----------------------------
    //キャラクターを初期化する
    __fn _initChara $ptr $block bl {
        $block
        v[$ptr..$ptr + SIZE_OF_CH - 1] = [$type, $state, -1, $id, $bit, $cell, $param1, $param2, $x, $y, $vx, $vy]
    }

    //キャラクターのポインタを取得する
    __fn _getCharaPtr $dvPtr $idx bl {
        v[__id($dvPtr)] = __id(charaHead) + ($idx) * SIZE_OF_CH
    }

    //キャラクタの状態を変える
    __fn _setCharaState $ptr $state bl {
        v[$ptr + MC_STATE..$ptr + MC_TIMER] = [$state, -1]
    }

    //キャラクタの状態を変える(一時変数)
    __fn _setCharaStateTemp $state bl {
        v[__id(state)..__id(state) + 1] = [$state, 0]
    }

    //キャラクタの速度制御
    __fn _setCharaSpeed $tag $acc bl {
        v[__id(tagVx)..__id(tagVx) + 1] = [$tag, $acc]
    }

    //攻撃属性を設定する
    //攻撃属性,衝突時の状態変化,横,縦,中心(相対),単位
    __fn _setAttackParam $type $state $halfWidth $halfHeight $x $y $unit bl {
        v[__id(atkType)..__id(atkY)] = [$type, $state, $halfWidth * $unit, $halfHeight * $unit, $x * $unit, $y * $unit]
    }

    //射撃属性を設定する
    //種類,タイプ,x,y,vx,vy
    __fn _setShootParam $chara $type $x $y $vx $vy $unit bl {
        v[__id(shtChara)..__id(shtVy)] = [$chara, $type, $x * $unit, $y * $unit, $vx * $unit, $vy * $unit]
    }

    //----------------------------
    //NPCキャラクターを初期化する
    __fn _initNpc $ptr $block bl {
        $block
        v[$ptr..$ptr + SIZE_OF_NPC - 1] = [$type, $state, -1, $bit, $cell, $param1, $x, $y]
    }

    //NPCキャラクターのポインタを取得する
    __fn _getNpcPtr $dvPtr $idx bl {
        v[__id($dvPtr)] = __id(npcHead) + ($idx) * SIZE_OF_NPC
    }

    //NPCキャラクタの状態を変える
    __fn _setNpcState $ptr $state bl {
        v[$ptr + MN_STATE..$ptr + MN_TIMER] = [$state, -1]
    }

    //NPCキャラクタの状態を変える(一時変数)
    __fn _setNpcStateTemp $state bl {
        v[__id(state)..__id(state) + 1] = [$state, 0]
    }

    //----------------------------
    //エフェクトを追加する(ftAを使用している)
    __fn _addEffect $block bl {
        $block
        ftA = __id(effHead) + effIndex * SIZE_OF_EFF
        v[ftA..ftA + SIZE_OF_EFF - 1] = [$type, -1, $cell, $scale, $x, $y]
        effIndex = (effIndex + 1) % EFF_NUM
    }

    //エフェクトのポインタを取得する
    __fn _getEffectPtr $dvPtr $idx bl {
        v[__id($dvPtr)] = __id(effHead) + ($idx) * SIZE_OF_EFF
    }

    //----------------------------
    //撃破演出デバッグ
    def EVENT_CMD_BATTLE_d1 = __str("",
"bgm,1
wait,30
defeat")

    //ボス戦前のイベントを省略
    def EVENT_CMD_BATTLE_d2 = __str("",
"wait,90
pause,1
bgm,1
pause,0
wait,8,
signal,2")

    //ボス戦前のイベント
    def EVENT_CMD_BATTLE = __str("",
"wait,90
pause,1
mes,0
port,1
face,0
mes,4
\c[7]【ゴメス】\c[0]
お前は！！えーと…
\c[2]「偽ゴメス」\c[0]だな！！！！！
                              \c[2](Shift / $u : 早送り)
mes,3
\c[7]【ゴメス】\c[0]
どうしてアレックスをさらった！？
掘られる前に言ってみろ！
face,1
mes,3
\c[7]【偽ゴメス】\c[0]
……
当然、アレックスの体…
mes,3
\c[7]【偽ゴメス】\c[0]
もしもの力で…
アレックスを\c[2]ＴＳロリ化\c[0]して…
se,0
mes,2
\c[7]【偽ゴメス】\c[0]
\c[2]幼女になったアレックスを…掘る…ッ！\c[0]
se,1
face,0
mes,2
\c[7]【ゴメス】\c[0]
！？
face,1
mes,2
\c[7]【偽ゴメス】\c[0]
俺は…ずっと考えてきた…
face,1
mes,3
\c[7]【偽ゴメス】\c[0]
なぜ、\c[2]ホモレイプ\c[0]は良くて…
\c[2]ロリレイプ\c[0]は受け入れられないのか…
mes,3
\c[7]【偽ゴメス】\c[0]
もしも、\c[2]ロリレイプ\c[0]ができるのなら…
俺はまず、最強の勇者をレイプする…！
face,0
mes,3
\c[7]【ゴメス】\c[0]
なんて奴だ…！
同意を得ないならまだしも、幼子に手を掛けようとは！
mes,3
\c[7]【ゴメス】\c[0]
そもそも！お前は身体だけを目当てにしている！
アレックスの貞操は奪えても、心までは奪えまい！
face,1
mes,3
\c[7]【偽ゴメス】\c[0]
どうでもいい…幼女になった勇者たちを掘る…
俺には、その資格がある…
se,0
mes,3
\c[7]【偽ゴメス】\c[0]
ゴメス博士が捨てた闇の装置
\c[2]「レベルドレイン・フェラチニオン」\c[0]だ…！
mes,3
\c[7]【偽ゴメス】\c[0]
アレックスが持っていた\c[2]「もしもの力」\c[0]は
今、俺の手にある…
mes,4
\c[7]【偽ゴメス】\c[0]
\c[2]「ゴメス以外バリア」\c[0]は、魔法じゃない…
ゴメス以外を吹っ飛ばす\c[2]「もしもの力」\c[0]そのもの…
まんまとお前は、おびき寄せられたわけだ…
mes,3
\c[7]【偽ゴメス】\c[0]
お前さえ消し去れば、俺の野望は実現する…
\c[2]ロリレイプに満ちた世界\c[0]だ…
mes,3
\c[7]【偽ゴメス】\c[0]
ついでにＴＳの素質のないゲイ共は皆殺しだ…
アレックスの穴兄弟とか気持ち悪いしな…
face,0
mes,2
\c[7]【ゴメス】\c[0]
外道め…
mes,3
\c[7]【ゴメス】\c[0]
ワシのチンポは自慢のチンポ
熱い使命を感じる事でも、そびえ立つ！
se,2
mes,3
\c[7]【ゴメス】\c[0]
この滾るイチモツにかけて！
男も女もLGBTその他諸々も、このワシが守る！
face,1
mes,3
\c[7]【偽ゴメス】\c[0]
使命…？
笑わせるな、義務シコチンポめ…
mes,3
\c[7]【偽ゴメス】\c[0]
ロリレイプの平穏の為に…
お前を永久に去勢してやる！
mes,-1
port,0
bgm,1
pause,0
wait,8
signal,2")

//ボスを倒した直後のイベント
def EVENT_CND_DEFEATED_BOSS = __str("",
"defeat"
)

//ボス戦から始める
def EVENT_CMD_START_DEBUG_1 = __str("",
"erase
load,1
start"
)

//脱出から始める
def EVENT_CMD_START_ESCAPE = __str("",
"erase
load,2
start"
)

//ゲーム開始イベント(通常)
def EVENT_CMD_START = __str("",
"erase
load,0
start"
)

//エンディング開始イベント
def EVENT_CMD_ENDING = __str("",
"pause,1
erase
ending"
)

//ゴールに入った時のイベント
def EVENT_CMD_GOAL = __str("",
"pause,1
goal"
)
    //------------------------------------------------------------------------------------
    //開始処理
    bl {
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, TS_MINIGAME, NUM_OF_STR)
        storeAndStopBGM()
        msgBottom()
        @label.jump "gameLoop"
    }

    @label.set "gameLoop"
    bl {
        //変数を一括で初期化する
        assignVarUsingDeclared(varHead, varFoot, 0)
        //ピクチャを全て透明化する
        @loop NUM_OF_PIC .dst(ftA) bl {
            ftA += PIC_HEAD
            @pic.move[ftA] .pos(OUT_RANGE, OUT_RANGE) .trans(100)
        }

        //ボス戦前の会話
        //_pushEvents(TRUE, TRUE, EVENT_CMD_BATTLE)
        //エンディング
        //_pushEvents(TRUE, TRUE, EVENT_CMD_ENDING)
        //ゲーム開始
        _pushEvents(TRUE, TRUE, EVENT_CMD_START)

        stopBGM(1000)

        fastFadeInTintOnly(1)
        @loop bl {
            @wait(0)

            //----------------------------
            //入力
            @key.input .dst(ftA) .left
            @key.input .dst(ftB) .right
            ftA = (ftB ? 1 : 0) - (ftA ? 1 : 0)
            inputX = (ftA * inputX <= 0) ? (ftA) : (inputX + ftA)

            @key.input .dst(ftA) .up
            @key.input .dst(ftB) .down
            ftA = (ftB ? 1 : 0) - (ftA ? 1 : 0)
            inputY = (ftA * inputY <= 0) ? (ftA) : (inputY + ftA)

            @key.input .dst(ftA) .decision
            inputD = ftA ? (inputD + 1) : 0
            @key.input .dst(ftA) .shift
            inputS = ftA ? (inputS + 1) : 0

            //----------------------------
            //ポーズ
            pauseProcces(TRUE, ftA, "gameEnd")

            //----------------------------
            //イベント
            //イベントコマンドによっては積まれていたコマンドが初期化される場合もある
            @if eventState != EVENT_ST_NONE bl {
                eventTimer += 1
            }

            pseudoSwitchState(eventState,
            [EVENT_ST_NONE, bl {
                //何もしない
            },
            EVENT_ST_READ, bl {
                @loop bl {
                    //イベントの状態によってループを打ち切る
                    @if eventState != EVENT_ST_READ bl {
                        @break
                    }
                    //イベントコマンドの数
                    strEvents .getLen(ftA)
                    //イベントコマンド無し
                    @if ftA <= 0 bl {
                        //何もしない状態に戻る
                        _changeEventState(EVENT_ST_NONE)
                    } .else bl {
                        //一行読み込み
                        strEvents .popLine(strLine)
                        //,で区切る
                        strLine .split(",", strCommand, ftA)
                        //パラメータ
                        strParam .toNum(eventParam)
                        //コマンドごとに分岐する

                        //wait,frame 一定時間待機
                        @if strCommand.eq "wait" bl {
                            _changeEventState(EVENT_ST_WAIT)
                        //pause,flag ポーズのON/OFF
                        } .elif strCommand.eq "pause" bl {
                            @if `eventParam bl {
                                bitOff(sceneBit, SC_BIT_GAME)
                            } .else bl {
                                bitOn(sceneBit, SC_BIT_GAME)
                            }
                        //signal,id キャラに信号を送る
                        } .elif strCommand.eq "signal" bl {
                            _getCharaPtr(pA, eventParam)
                            @if `v[pA + MC_STATE] > CH_ST_NONE bl {
                                v[pA + MC_BIT] |= CH_BIT_SIGNAL
                            }
                        //start スタートイベント
                        } .elif strCommand.eq "start" bl {
                            _changeEventState(EVENT_ST_START)
                        //goal ゴールイベント
                        } .elif strCommand.eq "goal" bl {
                            _changeEventState(EVENT_ST_GOAL)
                        //defeat ボス撃破イベント
                        } .elif strCommand.eq "defeat" bl {
                            _changeEventState(EVENT_ST_DEFEATED_BOSS)
                        //load,num ステージを開始する
                        } .elif strCommand.eq "load" bl {
                            stageNumber = eventParam
                            //マップデータを収めたピクチャ                                
                            @pic.show [PIC_MAPDATA] .repl(1, stageNumber) .pos(0, 0) .topLeft mapDataPicCmd
                            @pic.getInfo [PIC_MAPDATA] .baseRect(0, 0, mapWidth, mapHeight) .xywh

                            //プレイヤーを設置する
                            _getCharaPtr(pA, CH_ID_PLAYER)
                            _initChara(pA, bl {
                                $type = CH_TYPE_PL
                                $state = CH_ST_INIT
                                $id = -1
                                $x = ([  3,   2,  32][stageNumber] * TILE_SIZE_PX + TILE_SIZE_PX / 2) * UNIT_POS
                                $y = ([157,   6,   0][stageNumber] * TILE_SIZE_PX + TILE_SIZE_PX) * UNIT_POS
                            } )
                            //スクリーンのずれ
                            V2_set(scrAddX,
                                [-160, 0, -160][stageNumber],
                                [-178, 0, -120][stageNumber]
                            )
                            //初期スクリーン位置
                            V2_set(scrX,
                                [0, 32, 0][stageNumber],
                                [0,112, 0][stageNumber],
                            )
                            //シーンフラグ
                            sceneBit = [0, SC_BIT_SCR_SINGLE | SC_BIT_SCR_LOCK, SC_BIT_SHOW_TIMER | SC_BIT_SHAKE][stageNumber]
                            //bitOn(sceneBit, SC_BIT_SHOW_TIMER)
                            //画面全体を見てキャラを設置する and ステージ開始
                            bitOn(sceneBit, SC_BIT_SCR_INIT | SC_BIT_GAME)
                            //暗転
                            fastFadeInTintOnly(1)
                        //ending エンディングを開始する
                        } .elif strCommand.eq "ending" bl {
                            _changeEventState(EVENT_ST_ENDING)
                        //erase ゲーム中のキャラクタやピクチャを初期化する
                        } .elif strCommand.eq "erase" bl {
                            //変数の一部を一括で初期化する
                            assignVarUsingDeclared(initHead, varFoot, 0)
                            //ピクチャを初期化する
                            @loop CH_NUM .dst(pid) bl {
                                pid += PIC_CHARA
                                @pic.show[pid] .pos(OUT_RANGE, OUT_RANGE) .trans(100) .cell(0) charaPicCmd
                            }
                            @loop NPC_NUM .dst(pid) bl {
                                pid += PIC_NPC
                                @pic.show[pid] .pos(OUT_RANGE, OUT_RANGE) .trans(100) .cell(0) npcPicCmd
                            }
                            @loop EFF_NUM .dst(pid) bl {
                                pid += PIC_EFFECT
                                @pic.show[pid] .pos(OUT_RANGE, OUT_RANGE) .trans(100) .cell(0) effectPicCmd
                            }
                            @loop 4 .dst(pid) bl {
                                pid += PIC_BACK
                                @pic.move[pid] .pos(OUT_RANGE,OUT_RANGE) .trans(100)
                            }
                            @loop MAP_SHOW_NUM_Y .dst(ay) bl {
                                @loop MAP_SHOW_NUM_X .dst(ax) bl {
                                    pid = PIC_TILE + ay * MAP_SHOW_NUM_X + ax
                                    hidePicture(pid)
                                }
                            }
                        //retry リトライ選択肢
                        } .elif strCommand.eq "retry" bl {
                            replayProcess("gameLoop", "gameEnd")
                        //bgm,num BGMを流す(0で停止)
                        } .elif strCommand.eq "bgm" bl {
                            @if enableDedicatedBGM.isOn bl {
                                //ステージ
                                @if eventParam == 0 bl {
                                    @bgm.play "musmus_kyuketuki" .opt(0, 80, 100, 50)
                                //ボス
                                } .elif eventParam == 1 bl {
                                    @bgm.play "boss03" .opt(0, 100, 100, 50)
                                //脱出
                                } .elif eventParam == 2 bl {
                                    @bgm.play "CM0065-hishou" .opt(0, 100, 100, 50)
                                //フェードアウト
                                } .else bl {
                                    @bgm.fadeout(1000)
                                }
                            }
                        //se,num 効果音
                        } .elif strCommand.eq "se" bl {
                            //衝撃1
                            @if eventParam == 0 bl {
                                @se.play "Combat1" .opt(80, 100, 50)
                            //衝撃2
                            } .elif eventParam == 1 bl {
                                @se.play "Thunder1" .opt(80, 100, 50)
                            //覚悟
                            } .elif eventParam == 2 bl {
                                @se.play "Flash2" .opt(80, 100, 50)
                            }
                        //port,num 立ち絵を展開 or 消去
                        } .elif strCommand.eq "port" bl {
                            //消去
                            @if eventParam <= 0 bl {
                                $P = 16
                                @pic.move[PIC_PORTRAIT+1] .relative .pos(-$P, 0) .trans(100) .scale(0) .time(1)
                                @pic.move[PIC_PORTRAIT+0] .relative .pos($P, 0) .trans(100) .scale(0) .time(1)
                            //ゴメスと偽ゴメス
                            } .elif eventParam == 1 bl bl {
                                $P = 64
                                @pic.show [PIC_PORTRAIT+1] .pos(-$P, 0) .rangeAnim(4, 1, 2) portraitPicCmd
                                @pic.show [PIC_PORTRAIT+0] .pos(WINDOW_WIDTH + $P - PORTRAIT_WIDTH, 0) .cell(3) portraitPicCmd
                                @se.play "Wind1" .opt(100, 140, 50)
                                _changeEventState(EVENT_ST_PORTRAIT)
                            }
                        //face,num 立ち絵移動
                        } .elif strCommand.eq "face" bl {
                            $P = 4
                            $C = 50
                            @if eventParam == 0 bl {
                                @pic.move [PIC_PORTRAIT+1] .pos(0, 0) .topLeft .rgbs(100, 100, 100, 100) .time(1)
                                @pic.move [PIC_PORTRAIT+0] .pos(WINDOW_WIDTH - PORTRAIT_WIDTH + $P) .topLeft .rgbs($C, $C, $C, 100) .time(1)
                            } .elif eventParam == 1 bl {
                                @pic.move [PIC_PORTRAIT+1] .pos(-$P, 0) .topLeft .rgbs($C, $C, $C, 100) .time(1)
                                @pic.move [PIC_PORTRAIT+0] .pos(WINDOW_WIDTH - PORTRAIT_WIDTH) .topLeft .rgbs(100, 100, 100, 100) .time(1)
                            }
                        //mes,num メッセージの表示 or メッセージウィンドウの消去
                        } .elif strCommand.eq "mes" bl {
                            $P = 4
                            $H = 80
                            //消去
                            @if eventParam <= -1 bl {
                                @pic.move [PIC_MESSAGE] .pos($P, WINDOW_HEIGHT - $H) .topLeft .trans(100) .time(1)
                            //表示のみ
                            } .elif eventParam == 0 bl {
                                @pic.strpic [PIC_MESSAGE] "" .pos(-$P, WINDOW_HEIGHT - $H) .topLeft .size(WINDOW_WIDTH, $H) .font("", 12) baseStrPicCmd
                                @pic.move [PIC_MESSAGE] .relative .pos($P, 0) .time(1)
                            //文章を表示
                            } .else bl {
                                strMessage .asg("")
                                @loop eventParam bl {
                                    strEvents .popLine(strLine)
                                    strMessage .cat(__str("\", strLine, NEWLINE) .extract)
                                }
                                @pic.strpic [PIC_MESSAGE] strMessage .pos(-$P, WINDOW_HEIGHT - $H) .topLeft .size(WINDOW_WIDTH, $H) .font("", 12) baseStrPicCmd
                                @pic.move [PIC_MESSAGE] .relative .pos($P, 0) .time(1)
                                _changeEventState(EVENT_ST_MESSAGE)
                            }
                        }
                    }
                }
            },
            //一定フレーム待機する
            EVENT_ST_WAIT, bl {
                @if eventTimer >= eventParam bl {
                    _changeEventState(EVENT_ST_READ)
                }
            },
            //立ち絵を表示する
            EVENT_ST_PORTRAIT, bl {
                //立ち絵をスライドさせる
                @if `eventTimer % 4 == 0 bl {
                    $P = 1
                    @pic.move [PIC_PORTRAIT+1] .pos(0, 0) .topLeft .time($P)
                    @pic.move [PIC_PORTRAIT+0] .pos(WINDOW_WIDTH - PORTRAIT_WIDTH, 0) .topLeft .time($P)
                }
                @if eventTimer > 40 bl {
                    _changeEventState(EVENT_ST_READ)
                }
            },
            //メッセージ送り
            EVENT_ST_MESSAGE, bl {
                //決定キーで送る。シフトか下で早送り
                @if `inputD == 1 bl {
                    _changeEventState(EVENT_ST_READ)
                    @se.play "page1" .opt(80, 120, 50)
                } .elif `FAST_FORWARD_OP bl {
                    _changeEventState(EVENT_ST_READ)
                }
            },
            //ステージ開始演出
            EVENT_ST_START, bl {
                _getCharaPtr(pA, CH_ID_PLAYER)
                //最初のステージ:ダッシュ状態で前進する
                @if stageNumber == 0 bl {
                    //扉を設置する
                    @if eventTimer == 0 bl {
                        _addEffect(bl {
                            $type = EFF_TYPE_GATE
                            $scale = 100
                            $x = v[pA + MC_X] / UNIT_POS
                            $y = v[pA + MC_Y] / UNIT_POS - CH_PIC_SIZE / 2
                        } )
                    }
                    //少し間を置く
                    @if eventTimer > 10 bl {
                        //戸を叩く
                        @if inputD == 1 bl {
                            @scr.shake .once(1) .value(1, 9)
                            @se.play "Blow7" .opt(100, 100, 50)
                        }
                        //戸をぶち破る
                        @if inputS == 1 bl {
                            _setCharaState(pA, PL_ST_DASH)
                            v[pA + MC_VX] = 4 * UNIT_POS
                            @scr.shake .once(2) .value(4, 9)
                            @se.play "Explosion2" .opt(100, 100, 50)
                            //10F後にBGMと操作受付を開始
                            _pushEvents(FALSE, TRUE, __str("wait,10", NEWLINE,"bgm,0"))
                        }
                    }
                //ボスステージ:上に飛び上がる
                } .elif stageNumber == 1 bl {
                    _setCharaState(pA, PL_ST_FALL)
                    v[pA + MC_VY] = -8 * UNIT_POS
                    _pushEvents(FALSE, TRUE, EVENT_CMD_BATTLE)

                    //ボスを設置する
                    _getCharaPtr(pA, CH_ID_BOSS)
                    _initChara(pA, bl {
                        $type = CH_TYPE_EN_BOSS_1
                        $state = CH_ST_INIT
                        $id = -1
                        $x = (5 * TILE_SIZE_PX + TILE_SIZE_PX / 2) * UNIT_POS
                        $y = (4 * TILE_SIZE_PX + TILE_SIZE_PX) * UNIT_POS
                    } )
                    //アレックスを設置する
                    _getCharaPtr(pA, CH_ID_ALEX)
                    _initChara(pA, bl {
                        $type = CH_TYPE_EN_BOSS_ALEX
                        $state = CH_ST_INIT
                        $id = -1
                        $x = (4 * TILE_SIZE_PX) * UNIT_POS
                        $y = (3 * TILE_SIZE_PX + TILE_SIZE_PX) * UNIT_POS
                    } )
                    
                //脱出ステージ:落下状態
                } .elif stageNumber == 2 bl {
                    _setCharaState(pA, PL_ST_STAMP)
                    v[pA + MC_VY] = 2 * UNIT_POS
                    //揺れ
                    shakeTimer = 60 * 2
                    @scr.shake .once(10) .value(2, 9)
                    @se.play "Earthquake1" .opt(80, 80, 50)
                    //60f後にBGMと操作受付を開始する
                    _pushEvents(FALSE, TRUE, __str("wait,60", NEWLINE,"bgm,2"))
                }
            },
            //ボス撃破演出
            EVENT_ST_DEFEATED_BOSS, bl {
                _getCharaPtr(pA, CH_ID_EV_BOSS)
                _getCharaPtr(pB, CH_ID_EV_PLAYER)
                _getCharaPtr(pC, CH_ID_EV_ALEX)

                //登場
                @if `between(eventTimer, 0, 240) bl {
                    //一時停止
                    @if eventTimer == 0 bl {
                        bitOff(sceneBit, SC_BIT_GAME)
                        @se.play "Thunder10" .opt(80, 100, 50)
                        @scr.flash .once(2) .rgbv(31, 31, 31, 24)
                    }

                    //フラッシュと同時にキャラクターを消す
                    @if eventTimer == 60 - 1 bl {
                        //キャラを全て消す
                        @loop CH_NUM .dst(iA) bl {
                            _getCharaPtr(pA, iA)
                            @if `v[pA + MC_STATE] > CH_ST_DELETE bl {
                                v[pA + MC_STATE] = CH_ST_DELETE
                            }
                        }
                        //エフェクトを全て消す
                        //タイマーを適当に加算する
                        @loop EFF_NUM .dst(iA) bl {
                            _getEffectPtr(pA, iA)
                            v[pA + ME_TIMER] = 999
                        }
                        @se.play "Explosion6" .opt(100, 100, 50)
                        @scr.tint .rgbs(200, 200, 200, 100) .time(0)
                    }
                    //偽ゴメス設置
                    @if eventTimer == 60 bl {
                        _initChara(pA, bl {
                            $type = CH_TYPE_EVENT
                            $state = CH_ST_ACTIVE
                            $bit = CH_BIT_HREV
                            $cell = CH_CELL_EN_BOSS + 26
                            $id = -1
                            $x = (4 * TILE_SIZE_PX) * UNIT_POS
                            $y = (4 * TILE_SIZE_PX + TILE_SIZE_PX) * UNIT_POS
                        } )
                    }
                    //フラッシュ解除
                    @if eventTimer == 80 bl {
                        bitOn(sceneBit, SC_BIT_GAME)
                        @scr.tint .rgbs(100, 100, 100, 100) .time(10)
                        @scr.shake .once(4) .value(2, 9)
                    }
                    //二人はプリキュア
                    @if eventTimer == 140 bl {
                        _initChara(pB, bl {
                            $type = CH_TYPE_EVENT
                            $state = CH_ST_ACTIVE
                            $bit = CH_BIT_COLL_MAP | CH_BIT_GRAVITY
                            $cell = CH_CELL_PL + 19
                            $id = -1
                            $x = (2 * TILE_SIZE_PX) * UNIT_POS
                            $y = (1 * TILE_SIZE_PX + TILE_SIZE_PX) * UNIT_POS
                        } )
                        _initChara(pC, bl {
                            $type = CH_TYPE_EVENT
                            $state = CH_ST_ACTIVE
                            $bit = CH_BIT_COLL_MAP | CH_BIT_GRAVITY | CH_BIT_HREV
                            $cell = CH_CELL_ALEX + 5
                            $id = -1
                            $x = (6 * TILE_SIZE_PX) * UNIT_POS
                            $y = (1 * TILE_SIZE_PX + TILE_SIZE_PX) * UNIT_POS
                        } )
                    }
                    //着地
                    @if eventTimer == 140 + 35 bl {
                        v[pB + MC_CELL] = CH_CELL_PL + 11
                        v[pC + MC_CELL] = CH_CELL_ALEX + 6
                        @se.play "Blow1" .opt(90, 130, 50)
                    }
                    //慌てる
                    @if `between(eventTimer, 180, 240) bl {
                        @if `!(eventTimer % 15) bl {
                            v[pA + MC_BIT] = (v[pA + MC_BIT] & CH_BIT_HREV) ? 0 : CH_BIT_HREV
                        }
                    }
                }
                //ラッシュ
                @if `between(eventTimer, 240, 930) bl {
                    //飛び掛かる
                    @if eventTimer == 240 bl {
                        v[pB + MC_BIT] = CH_BIT_COLL_MAP
                        v[pB + MC_CELL] = CH_CELL_PL + 34
                        v[pB + MC_VX..pB + MC_VY] = [ 3 * UNIT_POS, -6 * UNIT_POS]
                        v[pC + MC_BIT] = CH_BIT_COLL_MAP | CH_BIT_HREV
                        v[pC + MC_CELL] = CH_CELL_ALEX + 7
                        v[pC + MC_VX..pC + MC_VY] = [-3 * UNIT_POS, -6 * UNIT_POS]
                        @se.play "jump_anim" .opt(80, 120, 50)
                    }
                    //低速
                    @if eventTimer == 250 bl {
                        v[pB + MC_VX..pB + MC_VY] = [ 1 * UNIT_POS / 5, -1 * UNIT_POS / 2]
                        v[pC + MC_VX..pC + MC_VY] = [-1 * UNIT_POS / 5, -1 * UNIT_POS / 2]
                        @se.play "Fog2" .opt(80, 90, 50)
                    }
                    //止まる
                    @if eventTimer == 320 bl {
                        v[pB + MC_VX..pB + MC_VY] = [0, 0]
                        v[pC + MC_VX..pC + MC_VY] = [0, 0]
                        @scr.flash .once(1) .rgbv(31, 31, 31, 24)
                    }
                    //殴りまくる
                    @if `between(eventTimer, 320, 320 + 60 * 8) bl {
                        //ガード
                        @if eventTimer < 320 + 60 * 3 bl {
                            easyAnimation(ftA, TRUE, CH_CELL_EN_BOSS+4, CH_CELL_EN_BOSS+5, eventTimer, 4)
                            v[pA + MC_CELL] = ftA
                        }
                        //ガード破壊
                        @if eventTimer == 320 + 60 * 3 bl {
                            @se.play "GlassShatter" .opt(80, 80, 50)
                            @scr.flash .once(2) .rgbv(31, 31, 31, 24)
                        }
                        //一発
                        @if `!(eventTimer % 10) bl {
                            //音とパターン
                            @if eventTimer < 320 + 60 * 3 bl {
                                ftA = rnd(10, 14) * 10
                                @se.play "Sword2" .opt(80, ftA, 50)
                            } .else {
                                v[pA + MC_CELL] = (rnd(1,3) + (v[pA + MC_CELL] - (CH_CELL_EN_BOSS +  6))) % 4 + CH_CELL_EN_BOSS + 6
                                ftA = rnd(10, 14) * 10
                                @se.play "punch2" .opt(100, ftA, 50)
                                @scr.shake .once(1) .value(2, 9)
                            }
                            //左右パターン
                            v[pB + MC_CELL] = (rnd(1,3) + (v[pB + MC_CELL] - (CH_CELL_PL + 40))) % 4 + CH_CELL_PL + 40
                            v[pC + MC_CELL] = (rnd(1,3) + (v[pC + MC_CELL] - (CH_CELL_ALEX + 9))) % 4 + CH_CELL_ALEX + 9
                            //エフェクト
                            V2_set(ax,
                                v[pA + MC_X] / UNIT_POS + rnd(-24, 24),
                                v[pA + MC_Y] / UNIT_POS + rnd(-24, 24) - 32
                            )
                            ftB = [-150, 150][rnd(0, 1)]
                            _addEffect(bl {
                                $type = EFF_TYPE_COMMON
                                $cell = 13
                                $scale = ftB
                                $x = ax
                                $y = ay
                            } )
                        }
                    }
                    //打ち上げ
                    @if eventTimer == 800 bl {
                        stopBGM(0)
                        @se.stop
                        @se.play "hit_db" .opt(90, 110, 50)
                        @scr.flash .once(2) .rgbv(31, 31, 31, 24)
                        @scr.shake .once(2) .value(2, 9)
                        v[pA + MC_CELL] = CH_CELL_EN_BOSS + 8
                        v[pA + MC_BIT] = CH_BIT_SCREEN//画面外で消える
                        v[pA + MC_VY] = -6 * UNIT_POS
                        v[pB + MC_CELL] = CH_CELL_PL + 43
                        v[pB + MC_VY] = -1 * UNIT_POS / 5
                        v[pC + MC_CELL] = CH_CELL_ALEX + 9
                        v[pC + MC_VY] = -1 * UNIT_POS / 5
                    }
                    //落下
                    @if eventTimer == 860 bl {
                        v[pB + MC_BIT] = CH_BIT_COLL_MAP | CH_BIT_GRAVITY
                        v[pC + MC_BIT] = CH_BIT_COLL_MAP | CH_BIT_GRAVITY | CH_BIT_HREV
                    }
                    //決めポーズ
                    @if eventTimer == 930 bl {
                        v[pB + MC_CELL] = CH_CELL_PL + 44
                        v[pC + MC_CELL] = CH_CELL_ALEX + 6
                        v[pC + MC_BIT] = CH_BIT_COLL_MAP | CH_BIT_GRAVITY
                        @se.play "Holy9" .opt(90, 100, 50)
                    }
                }
                //オチ
                @if `between(eventTimer, 920, 1800) bl {
                    //ファンファーレ
                    @if eventTimer == 960 bl {
                        startBGM("JFanfare 1", FALSE, 0, 90, 120, 50)
                    }
                    //気付く
                    @if `between(eventTimer, 1350, 1370) bl {
                        ftB = eventTimer - 1350
                        easyAnimation(ftA, FALSE, CH_CELL_PL+45, CH_CELL_PL+46, ftB, 6)
                        v[pB + MC_CELL] = ftA
                        easyAnimation(ftA, FALSE, CH_CELL_ALEX+13, CH_CELL_ALEX+14, ftB, 6)
                        v[pC + MC_CELL] = ftA

                        @if eventTimer == 1350 bl {
                            @se.play "Blow1" .opt(90, 130, 50)
                        }
                    }
                    //諦める
                    @if eventTimer == 1430 bl {
                        v[pC + MC_CELL] = CH_CELL_ALEX+15
                    }
                    //突進
                    @if `between(eventTimer, 1430, 1430 + 60) bl {
                        easyAnimation(ftA, TRUE, CH_CELL_PL+4, CH_CELL_PL+9, eventTimer, 2)
                        v[pB + MC_CELL] = ftA

                        @if eventTimer < 1430 + 60 bl {
                            v[pB + MC_VX] = -1 * UNIT_POS / 5
                        } .else bl {
                            v[pB + MC_VX] = 6 * UNIT_POS
                        }

                        @if eventTimer == 1430 + 60 bl {
                            @se.play "Escape" .opt(90, 100, 50)
                        }
                    }
                    //地震
                    @if eventTimer == 1430 + 70 bl {
                        v[pB + MC_CELL] = CH_CELL_PL + 47
                        v[pB + MC_VX] = 0
                        v[pC + MC_CELL] = CH_CELL_ALEX + 16

                        @se.play "Earthquake1" .opt(100, 100, 50)
                        @scr.shake .once(14) .value(2, 9)
                    }
                    //地面が崩れる
                    //8マス分。それ以上やるとメモリが破壊されるかも
                    @if `between(eventTimer, 1620, 1620 + 6 * 7) bl {
                        @if `!((eventTimer - 1620) % 6) bl {
                            ax = 7 - clamp((eventTimer - 1620) / 6, 0, 7)
                            ay = 7
                            //マップデータ書き換え
                            ftA = 0x00
                            @pic.setPixel [PIC_MAPDATA] .xywh(ax, ay, 1, 1) .src(ftA)
                            //エフェクト
                            _addEffect(bl {
                                $type = EFF_TYPE_COMMON
                                $cell = 9
                                $scale = 100
                                $x = ax * TILE_SIZE_PX + TILE_SIZE_PX / 2
                                $y = ay * TILE_SIZE_PX + TILE_SIZE_PX / 2 - 24
                            } )
                            @se.play "Earth1" .opt(80, 100, 50)
                        }
                    }
                }
                //次のステージへ
                @if eventTimer == 1740 bl {
                    _pushEvents(FALSE, TRUE, "goal")
                }
                //db_log(__str("\",eventTimer))
            },
            //ゴール演出
            EVENT_ST_GOAL, bl {
                //2
                @if stageNumber == 2 bl {
                    //白
                    @if eventTimer == 0 bl {
                        stopBGM(100)
                        @scr.tint .rgbs(200, 200, 200, 100) .time(6)                    
                        @scr.shake .once(0) .value(0, 1)
                        @se.stop
                    }
                    //残響音
                    @if `eventTimer <= 90 && eventTimer % 30 == 0 bl {
                        ftA = lerp(100, 10, eventTimer, 120)
                        @se.play "Wind1" .opt(ftA, 80, 50)
                    }
                    //エンディングへ
                    @if eventTimer > 180 bl {
                        _pushEvents(FALSE, TRUE, "ending")
                    }
                //0-1
                } .else bl {
                    //暗転
                    @if eventTimer == 0 bl {
                        stopBGM(1000)
                        @scr.tint .rgbs(0, 0, 0, 100) .time(2)
                        @se.play "Wind1" .opt(100, 100, 50)
                    }

                    //次のステージへ
                    @if eventTimer > 20 bl {
                        ftA = stageNumber + 1
                        _pushEvents(FALSE, TRUE, __str("erase", NEWLINE, "load,\",ftA, NEWLINE, "start"))
                    }
                }
            },
            //エンディング
            EVENT_ST_ENDING, bl {
                //一枚絵を表示する
                @if eventTimer == 0 bl {
                    //タイマー非表示
                    hidePicture(PIC_TIMER)
                    //BGM停止
                    stopBGM()
                    //暗転解除
                    @scr.tint .rgbs(100, 100, 100, 100) .time(2)
                    //一枚絵
                    @pic.show [PIC_SINGLE] .pos(0, 0) .topLeft .cell(1) .rgbs(100, 100, 100, 100) singlePicCmd
                    //実績
                    checkSetAchievement(achievedGomez, gameTimer <= GT_ACHIEVE_COUNT)
                }
                //BGM
                @if eventTimer == 25 bl {
                    startBGM("gomez song", FALSE, 0, 70, 100, 50)
                }
                //ここで一旦タイマーを抑える
                @if eventTimer == 30 bl {
                    @if `!NEXT_SCENE_OP bl {
                        eventTimer -= 1
                    }
                }
                //一枚絵を変色させる
                @if eventTimer == 31 bl {
                    @pic.move [PIC_SINGLE] .relative .pos(0, 0) .scale(0) .trans(0) .rgbs(100, 70, 0, 0) .time(5)
                }
                //結果を表示する
                @if eventTimer == 120 bl {
                    //スコアを表示する
                    strMessage .asg(__str("\c[2]救 出 完 了 ！\c[0]", NEWLINE))
                    getTimerString(1, __id(strLine), gomezTowerScore)
                    strMessage .cat(__str("\c[6]以前のタイム : \c[0]\", strLine, NEWLINE) .extract)
                    getTimerString(1, __id(strLine), gameTimer)
                    strMessage .cat(__str("\c[6]今回のタイム : \c[0]\", strLine, NEWLINE) .extract)
                    strMessage .cat(__str("\c[6]受けたダメージ : \c[0]\", damageCnt, NEWLINE) .extract)
                    @pic.strpic [PIC_MESSAGE] strMessage .pos(WINDOW_WIDTH - 4, 8) .topRight .scale(100) .font("", 14) .bold baseStrPicCmd
                    @se.play "bom0" .opt(80, 100, 50)
                    @scr.shake .once(1) .value(3, 6)

                    //ここでハイスコアを更新する
                    @if `0 >= gomezTowerScore || gameTimer < gomezTowerScore bl {
                        gomezTowerScore = gameTimer
                    }
                }
                //終わり
                @if `eventTimer >= 200 bl {
                    _pushEvents(FALSE, TRUE, "retry")
                }
            } ],
            bl {}
            )

            //----------------------------
            //ヒットストップ
            @if stopTimer > 0 bl {
                stopTimer -= 1
                @continue
            }
            //----------------------------
            //ゲーム中でなければ以下の処理をスキップする
            @if `!(sceneBit & SC_BIT_GAME) bl {
                @continue
            }
            //----------------------------
            //ゲーム時間
            //イベント中はカウントしない
            @if `gameTimer < MAX_TIMER && !IN_EVENT bl {
                gameTimer += 1
                //一度表示すると消えない
                @if `(sceneBit & SC_BIT_SHOW_TIMER) && !(gameTimer % UNIT_FPS) bl {
                    getTimerString(1, __id(strLine), gameTimer)
                    @pic.strpic [PIC_TIMER] strLine .pos(TIMER_X, TIMER_Y) .topLeft .scale(100) .font("", 14) .bold .nobg .noframe .noPadding baseStrPicCmd
                }
            }

            //----------------------------
            //スクロールによるキャラクタ生成
            //プレイヤーに合わせる
            @if `!(sceneBit & SC_BIT_SCR_LOCK) bl {
                _getCharaPtr(pA, CH_ID_PLAYER)
                V2_set(scrX,
                    v[pA + MC_X] / UNIT_POS + scrAddX,
                    v[pA + MC_Y] / UNIT_POS + scrAddY
                )
                V2_clampPointInsideRect2(scrX, 0, 0, mapWidth * TILE_SIZE_PX - WINDOW_WIDTH, mapHeight * TILE_SIZE_PX - WINDOW_HEIGHT)
            }

            //画面サイズとマップタイルの都合に合わせて基準点は左にずれる
            V2_set(ax,
                scrX - (72 + 8),
                scrY - (72)
            )
            //タイル座標
            V2_divScalar(bx, ax, TILE_SIZE_PX)
            //判定条件
            ftA = abs(scrOldX - ax) >= TILE_SIZE_PX || abs(scrOldY - ay) >= TILE_SIZE_PX
            @if `(sceneBit & SC_BIT_SCR_INIT) || (!(sceneBit & SC_BIT_SCR_LOCK) && ftA ) bl {
                //タイルの中心座標
                V2_set(scrOldX,
                    ax / TILE_SIZE_PX * TILE_SIZE_PX + TILE_SIZE_PX / 2,
                    ay / TILE_SIZE_PX * TILE_SIZE_PX + TILE_SIZE_PX / 2
                )
                //基準となる点
                V2_asDivScalar(ax, TILE_SIZE_PX)
                //枠の広さ
                $W = 11
                $H = 9
                @loop $H .dst(by) bl {
                    @loop $W .dst(bx) bl {
                        //中空を取り除く
                        @if `!(sceneBit & SC_BIT_SCR_INIT) && between(by, 1, $H-2) bl {
                            //[0,1] -> [0,9]
                            @if bx > 1 bl {
                                @break
                            } .else bl {
                                bx *= $W - 1
                            }
                        }
                        //判定点
                        V2_add(cx, ax, bx)
                        //ピクセルを取得する
                        _getPixelFromMap(col, cx, cy)
                        _getMapTilePattern(col, col)
                        //何もない
                        @if col <= 0 bl{
                            @continue
                        }
                        //座標ID
                        ftA = (cx << 16) | (cy)
                        //生成座標
                        V2_set(cx,
                            cx * TILE_SIZE_PX + TILE_SIZE_PX / 2,
                            cy * TILE_SIZE_PX + TILE_SIZE_PX
                        )
                        V2_asMulScalar(cx, UNIT_POS)
                        //振り分け
                        $EI = 17
                        $ET = 8
                        $NI = 25
                        $NT = 16
                        //敵
                        @if `between(col, $EI, $EI + $ET - 1) {
                            //敵の種類
                            type = CH_TYPE_EN_1 + (col - $EI)
                            param1 = 0
                            //空きを探しつつIDの重複を探す
                            iB = -1
                            @loop CH_NUM .dst(iA) bl {
                                _getCharaPtr(pA, iA)
                                @if `v[pA + MC_STATE] > CH_ST_NONE bl {
                                    //座標IDチェック
                                    @if `v[pA + MC_ID] == ftA && v[pA + MN_TYPE] == type bl {
                                        iB = -1
                                        @break
                                    }
                                } .elif iB < 0  bl {
                                    iB = iA
                                }
                            }
                            //空きがない or IDが重複している
                            @if iB < 0 bl {
                                @continue
                            }
                            //生成
                            _getCharaPtr(pB, iB)
                            _initChara(pB, bl {
                                $type = type
                                $state = CH_ST_INIT
                                $param1 = param1
                                $id = ftA
                                $x = cx
                                $y = cy
                            } )
                        //NPC
                        } .elif `between(col, $NI, $NI + $NT - 1) {
                            //0-7:追跡キャラクタ 8-11:チュートリアルキャラクタ 12:入口 13:ゴール
                            ftA = col - $NI
                            @if `between(ftA, 0, 7) bl {
                                type = NPC_TYPE_CHASE
                                param1 = ftA
                            } .elif `between(ftA, 8, 11) bl {
                                type = NPC_TYPE_TUTORIAL
                                param1 = ftA - 8
                            } .elif `ftA == 12 bl {
                                type = NPC_TYPE_GATE
                                param1 = 0
                            } .elif `ftA == 13 bl {
                                type = NPC_TYPE_GOAL
                                param1 = 0
                            } .else bl {
                                //例外
                                @continue
                            }
                            //空きを探しつつパラメータ1の重複を探す
                            iB = -1
                            @loop NPC_NUM .dst(iA) bl {
                                _getNpcPtr(pA, iA)
                                @if `v[pA + MN_STATE] > NPC_ST_NONE bl {
                                    //パラメータチェック
                                    @if `v[pA + MN_PM_1] == param1 && v[pA + MN_TYPE] == type bl {
                                        iB = -1
                                        @break
                                    }
                                } .elif iB < 0  bl {
                                    iB = iA
                                }
                            }
                            //空きがない or パラメータが重複している
                            @if iB < 0 bl {
                                @continue
                            }
                            //生成
                            _getNpcPtr(pB, iB)
                            _initNpc(pB, bl {
                                $type = type
                                $state = NPC_ST_INIT
                                $param1 = param1
                                $x = cx
                                $y = cy
                            } )
                        }
                    }
                }
                //SC_BIT_SCR_INITは1Fのみ有効
                bitOff(sceneBit, SC_BIT_SCR_INIT)
            }
            //----------------------------
            //キャラクター
            @loop CH_NUM .dst(iA) bl {
                _getCharaPtr(pA, iA)
                @if `v[pA + MC_STATE] <= CH_ST_NONE bl {
                    @continue
                }
                //----------------------------
                //タイマー
                v[pA + MC_TIMER] += 1
                //----------------------------
                //一時変数
                type  = v[pA + MC_TYPE]
                state = v[pA + MC_STATE]
                timer = v[pA + MC_TIMER]
                bit   = v[pA + MC_BIT]
                cell  = v[pA + MC_CELL]
                param1 = v[pA + MC_PM_1]
                param2 = v[pA + MC_PM_2]
                V2_set(px, v[pA + MC_X],  v[pA + MC_Y] )
                V2_set(vx, v[pA + MC_VX], v[pA + MC_VY])
                _setCharaSpeed(0, 0)
                shtType = SHT_NONE
                atkType = ATK_NONE

                //----------------------------
                //マップのとの衝突処理
                @if `bit & CH_BIT_COLL_MAP bl {
                    //初期化
                    collBit = 0
                    bitOff(bit, CH_BIT_COLL_L | CH_BIT_COLL_T | CH_BIT_COLL_R | CH_BIT_COLL_B | CH_BIT_COLL_DAM | CH_BIT_CLIFF | CH_BIT_SLIP | CH_BIT_WALLRUN | CH_BIT_HIJUMP)
                    //速度が無いと判定を省略する
                    @if `vx || vy bl {
                        //判定用メタ変数
                        $IS_BLOCK          = between(col, 2, 15)
                        $IS_DAMAGE_BLOCK   = (col == 7)
                        $IS_HALF_BLOCK     = (col == 8)
                        $IS_BRAKABLE_BLOCK = (col == 9)
                        $IS_ICE_BLOCK      = (col == 10)
                        $IS_BOOST_BLOCK    = (col == 11)
                        $IS_FALLING        = vy > 0
                        $CHK_HORI          = iB <= 2
                        $CHK_VERT          = iB > 2
                        $CHK_CLIFF         = iB <= 0
                        //判定位置
                        V2_set(ax,
                            (vx > 0 ? 1 : -1) * CH_COLL_LR * UNIT_POS,
                            (vy > 0 ? (CH_COLL_B) : (CH_COLL_T)) * UNIT_POS
                        )
                        //中心と4隅を判定する
                        @loop 5 .dst(iB) bl {
                            //ピクセル座標
                            //横中心(縦速度無し),横(縦速度無し),縦(横速度込み)
                            @if iB == 0 bl {
                                V2_set(bx, px + vx + ax, py + CH_COLL_C * UNIT_POS )
                            } .elif iB == 1 bl {
                                V2_set(bx, px + vx + ax, py + CH_COLL_T * UNIT_POS )
                            } .elif iB == 2 bl {
                                V2_set(bx, px + vx + ax, py + CH_COLL_B * UNIT_POS )
                            } .elif iB == 3 bl {
                                V2_set(bx, px - CH_COLL_LR * UNIT_POS, py + vy + ay )
                            } .elif iB == 4 bl {
                                V2_set(bx, px + CH_COLL_LR * UNIT_POS, py + vy + ay )
                            }
                            V2_asDivScalar(bx, UNIT_POS * TILE_SIZE_PX)
                            //ピクセルを取得する
                            _getPixelFromMap(col, bx, by)
                            _getMapTilePattern(col, col)
                            col -= 1
                            //壁と衝突している
                            @if `$IS_BLOCK bl {
                                //横中心の場合、ビットフラグを立てるだけで衝突処理は行わない
                                @if `$CHK_CLIFF bl {
                                    //何もしない
                                } .else bl {
                                    //ダメージブロック
                                    @if `$IS_DAMAGE_BLOCK bl {
                                        bitOn(bit, CH_BIT_COLL_DAM)
                                    //ハーフブロックの場合、横の衝突判定がなく、落下していて、移動前と移動後のタイル座標が異なる時に衝突する
                                    } .elif `$IS_HALF_BLOCK bl {
                                        @if `$CHK_VERT && $IS_FALLING && (py + vy + ay) / (TILE_SIZE_PX * UNIT_POS) != (py + ay) / (TILE_SIZE_PX * UNIT_POS) bl {
                                            //判定する
                                        } .else bl {
                                            @continue
                                        }
                                    //壊れるブロック
                                    } .elif `$IS_BRAKABLE_BLOCK bl {
                                        //横 or 縦
                                        @if `($CHK_HORI && (bit & CH_BIT_BREAK_H)) || ($CHK_VERT && (bit & CH_BIT_BREAK_V)) bl {
                                            //ピクセルを消去する
                                            ftA = 0
                                            @pic.setPixel [PIC_MAPDATA] .xywh(bx, by, 1, 1) .src(ftA)
                                            //破壊エフェクト
                                            _addEffect(bl {
                                                $type = EFF_TYPE_COMMON
                                                $cell = 9
                                                $scale = 125
                                                $x = bx * TILE_SIZE_PX + TILE_SIZE_PX / 2
                                                $y = by * TILE_SIZE_PX + TILE_SIZE_PX / 2
                                            } )
                                            @se.play "Earth1" .opt(90, 100, 50)
                                            //その後の衝突処理を無視する
                                            @continue
                                        }
                                    //氷ブロック
                                    } .elif `$IS_ICE_BLOCK bl {
                                        //氷を解かす
                                        @if `bit & CH_BIT_MELT bl {
                                            //ピクセルを消去する
                                            ftA = 0
                                            @pic.setPixel [PIC_MAPDATA] .xywh(bx, by, 1, 1) .src(ftA)
                                            //破壊エフェクト
                                            _addEffect(bl {
                                                $type = EFF_TYPE_COMMON
                                                $cell = 9
                                                $scale = 125
                                                $x = bx * TILE_SIZE_PX + TILE_SIZE_PX / 2
                                                $y = by * TILE_SIZE_PX + TILE_SIZE_PX / 2
                                            } )
                                            @se.play "Ice2" .opt(80, 80, 50)
                                            //その後の衝突処理を無視する
                                            @continue
                                        }
                                        //滑る
                                        @if `$CHK_VERT && $IS_FALLING bl {
                                            bitOn(bit, CH_BIT_SLIP)
                                        }
                                    //加速ブロック
                                    } .elif `$IS_BOOST_BLOCK bl {
                                        //横は壁走り
                                        @if `$CHK_HORI bl {
                                            bitOn(bit, CH_BIT_WALLRUN)
                                        //縦はジャンプ台
                                        } .elif `$CHK_VERT bl {
                                            bitOn(bit, CH_BIT_HIJUMP)
                                        }
                                    }

                                    //x
                                    @if `$CHK_HORI bl {
                                        px = (vx > 0) ? (bx * TILE_SIZE_PX * UNIT_POS - ax - 1) : ((bx + 1) * TILE_SIZE_PX * UNIT_POS - ax + 1)
                                    //y
                                    } .elif `$CHK_VERT bl {
                                        py = (vy > 0) ? (by * TILE_SIZE_PX * UNIT_POS - ay - 1) : ((by + 1) * TILE_SIZE_PX * UNIT_POS - ay + 1)
                                    }
                                }

                                //衝突フラグ
                                collBit |= 1 << iB
                            }
                        }
                        //速度を初期化する
                        @if `collBit & ((1 << 1) | (1 << 2)) bl {
                            bit |= vx > 0 ? CH_BIT_COLL_R : CH_BIT_COLL_L
                            vx = 0
                        }
                        @if `collBit & ((1 << 3) | (1 << 4)) bl {
                            bit |= vy > 0 ? CH_BIT_COLL_B : CH_BIT_COLL_T
                            vy = 0
                        }
                        //崖捕まり判定
                        @if `collBit == (1 << 2) bl {
                            bit |= CH_BIT_CLIFF
                        }
                    }
                }
                //----------------------------
                //速度を適用する
                V2_asAdd(px, vx)
                //----------------------------
                pseudoSwitchState(type,
                //----------------------------
                //プレイヤー p1:壁ジャンプ回数 p2:無敵時間
                [CH_TYPE_PL, bl {
                    //毎フレームOFF
                    bitOff(bit, CH_BIT_BREAK_H | CH_BIT_BREAK_V | CH_BIT_COLL_ATK)
                    //被攻撃判定
                    @if `(bit & CH_BIT_COLL_DAM) && param2 <= 0 bl {
                        //プレイヤー被弾
                        _setCharaStateTemp(PL_ST_DAMAGE)
                        //跳ねる向き
                        @if `bit & CH_BIT_COLL_R bl {
                            sgn = 1
                        } .elif `bit & CH_BIT_COLL_L bl {
                            sgn = -1
                        } .else bl {
                            sgn = (bit & CH_BIT_HREV) ? -1 : 1
                        }
                        //後ろに跳ねる
                        V2_set(vx,
                            PL_KNOCKBACK_VX * sgn * UNIT_POS,
                            PL_KNOCKBACK_VY * UNIT_POS
                        )
                        bitOff(bit, CH_BIT_COLL_B)
                        //無敵時間
                        param2 = PL_INV_TIMER
                        //ダメージカウント
                        damageCnt += 1
                        //ヒットストップ
                        stopTimer = 2
                        @se.play "Damage2" .opt(100, 100, 50)
                    }
                    //無敵時間
                    @if param2 > 0 bl {
                        param2 -= 1
                    } .elif state != PL_ST_DAMAGE bl {
                        bitOn(bit, CH_BIT_COLL_ATK)
                    }
                    //左右入力
                    @if inputX > 0 bl {
                        iptSgn = 1
                    } .elif inputX < 0 bl {
                        iptSgn = -1
                    } .else bl {
                        iptSgn = 0
                    }
                    //共通操作
                    @if `!IN_EVENT bl {
                        //定数
                        $JUMP_SWITCH = between(inputD, 1, 4)
                        $JUMP_DOWN = inputD > 0
                        $DASH_SWITCH = between(inputS, 1, 16)
                        $STAMP_SWITCH = between(inputD, 1, 4)

                        //振り向き
                        @if `state & (CH_ST_ACTIVE | PL_ST_WALK | PL_ST_LAND | PL_ST_HIJUMP | PL_ST_JUMP | PL_ST_FALL) bl {
                            @if `inputX > 0 && (bit & CH_BIT_HREV) bl {
                                bitOff(bit, CH_BIT_HREV)
                            } .elif `inputX < 0 && !(bit & CH_BIT_HREV) bl {
                                bitOn(bit, CH_BIT_HREV)
                            }
                        }
                        //地上速度
                        @if `state & (CH_ST_ACTIVE | PL_ST_WALK | PL_ST_LAND) bl {
                            _setCharaSpeed(3 * UNIT_POS * iptSgn, 4)
                        }
                        //滑る
                        @if `state & PL_ST_SLIP bl {
                            //速度が無いと止まる
                            @if vx == 0 bl {
                                _setCharaStateTemp(CH_ST_ACTIVE)
                            } .else bl {
                                //速度がある方を向く
                                @if `vx > 0 && (bit & CH_BIT_HREV) bl {
                                    bitOff(bit, CH_BIT_HREV)
                                } .elif `vx < 0 && !(bit & CH_BIT_HREV) bl {
                                    bitOn(bit, CH_BIT_HREV)
                                }
                                ftA = vx > 0 ? 1 : -1
                                _setCharaSpeed(3 * UNIT_POS * ftA, 4)
                            }
                        }
                        //空中制御
                        @if `state & (PL_ST_JUMP | PL_ST_FALL | PL_ST_HIJUMP | PL_ST_STAMP | PL_ST_STAMP_EN) bl {
                            _setCharaSpeed(3 * UNIT_POS * iptSgn, 2)
                        }
                        //崖捕まり
                        @if `(state & (PL_ST_FALL | PL_ST_DASH)) bl {
                            @if `bit & CH_BIT_CLIFF bl {
                                //向きが一致する
                                //ダッシュ中は入力なしで発動する
                                //壁走りを優先する
                                @if `((bit & CH_BIT_COLL_L) && (bit & CH_BIT_HREV)) || ((bit & CH_BIT_COLL_R) && !(bit & CH_BIT_HREV)) bl {
                                    @if `(state & PL_ST_DASH) && !(bit & CH_BIT_WALLRUN) bl {
                                        _setCharaStateTemp(PL_ST_CLIFF)
                                        @se.play "Jump1" .opt(80, 80, 50)
                                    }
                                }
                            }
                        }
                        //ジャンプ
                        @if `$JUMP_SWITCH bl {
                            //地上
                            @if `bit & CH_BIT_COLL_B bl {
                                //通常ジャンプ
                                @if `state & (CH_ST_ACTIVE | PL_ST_WALK | PL_ST_LAND | PL_ST_SLIP | PL_ST_CLIFF) bl {
                                    _setCharaStateTemp(PL_ST_JUMP)
                                    vy = -7 * UNIT_POS
                                    bitOff(bit, CH_BIT_COLL_B)
                                }
                                //ダッシュジャンプ
                                @if `state & PL_ST_DASH bl {
                                    timer = 0//ジャンプ直後はキャンセルができない
                                    vy = -7 * UNIT_POS
                                    bitOff(bit, CH_BIT_COLL_B)
                                }
                            //空中
                            } .else bl {
                                //崖登り中のジャンプ
                                @if `state & PL_ST_CLIFF bl {
                                    _setCharaStateTemp(PL_ST_JUMP)
                                    vy = -7 * UNIT_POS
                                //壁走りからのジャンプ
                                } .elif `state & PL_ST_WALLRUN bl {
                                    _setCharaStateTemp(PL_ST_DASH)
                                    //反転
                                    @if `bit & CH_BIT_HREV bl {
                                        bitOff(bit, CH_BIT_HREV)
                                    } .else bl {
                                        bitOn(bit, CH_BIT_HREV)
                                    }
                                    V2_set(vx,
                                        6 * UNIT_POS * ((bit & CH_BIT_HREV) ? -1 : 1),
                                        -3 * UNIT_POS
                                    )
                                    @se.play "Jump1" .opt(80, 120, 50)

                                //壁ジャンプ
                                //二回まで
                                } .elif `param1 < 2 && (state & PL_ST_DASH_EN) && timer < 12 bl {
                                    _setCharaStateTemp(PL_ST_JUMP)
                                    //反転
                                    @if `bit & CH_BIT_HREV bl {
                                        bitOff(bit, CH_BIT_HREV)
                                    } .else bl {
                                        bitOn(bit, CH_BIT_HREV)
                                    }
                                    V2_set(vx,
                                        2 * UNIT_POS * ((bit & CH_BIT_HREV) ? -1 : 1),
                                        [-7, -5][param1] * UNIT_POS
                                    )
                                    param1 += 1
                                }
                            }
                        }
                        //急降下アタック
                        @if `$STAMP_SWITCH bl {
                            @if `(state & PL_ST_FALL) ||  ((state & PL_ST_JUMP) && timer > 4) || ((state & PL_ST_DASH) && timer > 4) bl {
                                _setCharaStateTemp(PL_ST_STAMP)
                                vy = 7 * UNIT_POS
                            }
                        }
                        //ダッシュ
                        @if `$DASH_SWITCH && (state & (CH_ST_ACTIVE | PL_ST_WALK | PL_ST_LAND | PL_ST_FALL | PL_ST_SLIP)) bl {
                            _setCharaStateTemp(PL_ST_DASH)
                            //空中で出すと少し浮く
                            @if `!(bit & CH_BIT_COLL_B) bl {
                                vy = -1 * UNIT_POS
                            }
                            @se.play "Wind6" .opt(80, 100, 50)
                        }

                    //イベント中はとりあえず停止する
                    } .else bl {
                        //地上速度
                        @if `state & (CH_ST_ACTIVE | PL_ST_WALK | PL_ST_LAND) bl {
                            _setCharaSpeed(0, 4)
                        }
                        //空中制御
                        @if `state & (PL_ST_JUMP | PL_ST_FALL | PL_ST_HIJUMP | PL_ST_STAMP | PL_ST_STAMP_EN) bl {
                            _setCharaSpeed(0, 2)
                        }
                    }

                    //共通動作
                    //接地
                    @if `bit & CH_BIT_COLL_B bl {
                        //壁ジャンプカウンターを初期化
                        param1 = 0
                        //着地
                        @if `state & (PL_ST_JUMP | PL_ST_FALL | PL_ST_HIJUMP | PL_ST_STAMP_EN | PL_ST_DASH_EN) bl {
                            _setCharaStateTemp(PL_ST_LAND)
                        }
                        //滑る
                        @if `bit & CH_BIT_SLIP bl {
                            //滑り始め
                            @if `vx && (state & (CH_ST_ACTIVE | PL_ST_WALK | PL_ST_LAND)) bl {
                                _setCharaStateTemp(PL_ST_SLIP)
                                ftA = vx > 0 ? 1 : -1
                                _setCharaSpeed(4 * UNIT_POS * ftA, 4)
                            }
                        } .else bl {
                            //滑り終わり
                            @if `state & PL_ST_SLIP bl {
                                _setCharaStateTemp(PL_ST_WALK)
                            }
                        }
                    //空中
                    } .else bl {
                        //落下
                        @if `state & (CH_ST_ACTIVE | PL_ST_WALK | PL_ST_LAND | PL_ST_SLIP) bl {
                            _setCharaStateTemp(PL_ST_FALL)
                        }
                    }

                    //状態ごとの処理
                    pseudoSwitchState(state,
                    [CH_ST_ACTIVE, bl {
                        @if `vx bl {
                            _setCharaStateTemp(PL_ST_WALK)
                        } 
                    },
                    PL_ST_WALK, bl {
                        @if `!vx && (!inputX || IN_EVENT) bl {
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        } 
                    },
                    PL_ST_LAND, bl {
                        @if timer > 4*2 bl {
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    PL_ST_HIJUMP, bl {
                        @if timer > 2*12 bl {
                            _setCharaStateTemp(PL_ST_FALL)
                        }
                    },
                    PL_ST_JUMP, bl {
                        @if timer > 4*3 bl {
                            _setCharaStateTemp(PL_ST_FALL)
                        }
                    },
                    PL_ST_FALL, bl {
                        //踏みつけ判定
                        _setAttackParam(ATK_PL_FALL, 0, 16, 4, 0, -16, UNIT_POS)
                    },
                    PL_ST_STAMP, bl {
                        //縦のブロックを破壊する
                        bitOn(bit, CH_BIT_BREAK_V)
                        //スタンプアタック判定
                        _setAttackParam(ATK_PL_STAMP, 0, 24, 6, 0, -20, UNIT_POS)
                        //床に衝突すると跳ねる
                        //最初のフレームは無視する
                        @if timer > 0 bl {
                            @if `bit & CH_BIT_COLL_B bl {
                                //加速ブロックの上に落ちるとさらに高く飛べる
                                @if `bit & CH_BIT_HIJUMP bl {
                                    _setCharaStateTemp(PL_ST_HIJUMP)
                                    vy = -14 * UNIT_POS - UNIT_POS / 2//微調整
                                    @se.play "jet" .opt(100, 80, 50)
                                } .else bl {
                                    //地面間近で出すとハイジャンプに移行する
                                    @if timer < 4 bl {
                                        _setCharaStateTemp(PL_ST_HIJUMP)
                                        vy = -10 * UNIT_POS
                                        @se.play "Water3" .opt(80, 120, 50)
                                    } .else bl {
                                        _setCharaStateTemp(PL_ST_STAMP_EN)
                                        vy = -3 * UNIT_POS
                                    }
                                }
                                //煙エフェクト
                                _addEffect(bl {
                                    $type = EFF_TYPE_COMMON
                                    $cell = 5
                                    $scale = 100
                                    $x = px / UNIT_POS
                                    $y = py / UNIT_POS - CH_PIC_SIZE / 2
                                } )
                                @scr.shake .once(1) .value(2, 9)
                                @se.play "punch2" .opt(80, 100, 50)
                            }
                        }
                    },
                    PL_ST_STAMP_EN, bl {
                        @if timer > 18 bl {
                            _setCharaStateTemp(PL_ST_FALL)
                        }
                    },
                    PL_ST_DASH, bl {
                        sgn = (bit & CH_BIT_HREV) ? -1 : 1
                        _setCharaSpeed(5 * UNIT_POS * sgn, 4)
                        //ダッシュアタック判定
                        _setAttackParam(ATK_PL_DASH, 0, 8, 24, 20, -24, UNIT_POS)
                        //煙エフェクト
                        @if `timer % 12 == 0 && (bit & CH_BIT_COLL_B) bl {
                            _addEffect(bl {
                                $type = EFF_TYPE_COMMON
                                $cell = 1
                                $scale = 100 * sgn
                                $x = px / UNIT_POS
                                $y = py / UNIT_POS - CH_PIC_SIZE / 2
                            } )
                        }
                        //横のブロックを破壊する
                        bitOn(bit, CH_BIT_BREAK_H)
                        //入力を止めると止まる
                        @if `timer > 12 && (!inputS || IN_EVENT) bl {
                            //滑る or 歩き
                            ftA = (bit & CH_BIT_SLIP) ? PL_ST_SLIP : PL_ST_WALK
                            _setCharaStateTemp(ftA)
                        }
                        //壁に衝突すると後ろに跳ねる
                        //最初のフレームは無視する
                        @if timer > 0 bl {
                            @if `(sgn > 0 && (bit & CH_BIT_COLL_R)) || (sgn < 0 && bit & CH_BIT_COLL_L) bl {
                                //加速ブロックに当たると壁走りに移行する
                                @if `bit & CH_BIT_WALLRUN bl {
                                    _setCharaStateTemp(PL_ST_WALLRUN)
                                    V2_set(vx, 1 * UNIT_POS * sgn, -1 * UNIT_POS)
                                    //壁ジャンプの回数初期化
                                    param1 = 0
                                    @se.play "jet" .opt(90, 100, 50)

                                } .else bl {
                                    _setCharaStateTemp(PL_ST_DASH_EN)
                                    V2_set(vx, -2 * UNIT_POS * sgn, -3 * UNIT_POS)
                                    @scr.shake .once(1) .value(2, 9)
                                    @se.play "punch2" .opt(80, 100, 50)
                                }
                            }
                        }
                    },
                    PL_ST_DASH_EN, bl {
                        @if timer > 18 bl {
                            _setCharaStateTemp(PL_ST_FALL)
                        }
                    },
                    PL_ST_WALLRUN, bl {
                        sgn = (bit & CH_BIT_HREV) ? -1 : 1
                        V2_set(vx, 1 * UNIT_POS * sgn, -5 * UNIT_POS)
                        //ダッシュアタック判定
                        _setAttackParam(ATK_PL_DASH, 0, 24, 8, -8, -32, UNIT_POS)
                        //縦のブロックを破壊する
                        bitOn(bit, CH_BIT_BREAK_V)
                        //入力を止めると止まる
                        @if `timer > 12 && (!inputS || IN_EVENT) bl {
                            _setCharaStateTemp(PL_ST_JUMP)
                            V2_set(vx, 0, 0)
                        //天井にぶつかった
                        } .elif `bit & CH_BIT_COLL_T bl {
                            _setCharaStateTemp(PL_ST_HIJUMP)
                            V2_set(vx, 0, 0)
                            @scr.shake .once(1) .value(2, 9)
                            @se.play "punch2" .opt(80, 100, 50)
                        //壁に接着している or ダッシュ直後
                        } .elif `timer < 2 || (sgn > 0 && bit & CH_BIT_COLL_R) || (sgn < 0 && bit & CH_BIT_COLL_L) bl {
                        //崖に飛び出した
                        } .else bl {
                            _setCharaStateTemp(PL_ST_HIJUMP)
                        }
                    },
                    PL_ST_CLIFF, bl {
                        sgn = (bit & CH_BIT_HREV) ? -1 : 1
                        //ダッシュアタック判定
                        _setAttackParam(ATK_PL_DASH, 0, 8, 24, 20, -24, UNIT_POS)
                        //上昇する
                        @if `timer < 12 && (bit & (CH_BIT_COLL_L | CH_BIT_COLL_R)) bl {
                            V2_set(vx, 1 * UNIT_POS * sgn, -4 * UNIT_POS)
                        }
                        //ダッシュボタンを押しているとダッシュに移行する
                        @if `timer > 2 && (bit & CH_BIT_COLL_B) bl {
                            @if `inputS > 0 && !IN_EVENT bl {
                                ftA = PL_ST_DASH
                            } .else bl {
                                ftA = PL_ST_WALK
                            }
                            _setCharaStateTemp(ftA)
                        }
                        //落下状態に移行する
                        @if timer > 28 bl {
                            _setCharaStateTemp(PL_ST_FALL)
                        }
                    },
                    PL_ST_DAMAGE, bl {
                        @if timer > 30 bl {
                            ftA = (bit & CH_BIT_COLL_B) ? CH_ST_ACTIVE : PL_ST_FALL
                            _setCharaStateTemp(ftA)
                        //地面に触れると減速しつつ跳ねる
                        } .elif `bit & CH_BIT_COLL_B bl {
                            vx /= 2
                            vy = -3 * UNIT_POS
                        }
                    },
                    PL_ST_EVENT, bl {
                        //イベント側の操作を待つ
                    },
                    CH_ST_INIT, bl {
                        _setCharaStateTemp(PL_ST_EVENT)
                        bitOn(bit, CH_BIT_COLL_MAP | CH_BIT_GRAVITY | CH_BIT_SLIDE)
                    } ],
                    bl {}
                    )

                    //アニメーション
                    ftA = -1
                    pseudoSwitchState(state,
                    [CH_ST_ACTIVE, bl {
                        easyAnimation(ftA, TRUE, 0, 3, timer, 8)
                    },
                    PL_ST_WALK, bl {
                        easyAnimation(ftA, TRUE, 4, 9, timer, 4)
                    },
                    PL_ST_LAND, bl {
                        easyAnimation(ftA, FALSE, 10, 11, timer, 4)
                    },
                    PL_ST_HIJUMP, bl {
                        easyAnimation(ftA, TRUE, 12, 15, timer, 2)
                    },
                    PL_ST_JUMP, bl {
                        easyAnimation(ftA, FALSE, 16, 19, timer, 4)
                    },
                    PL_ST_FALL, bl {
                        easyAnimation(ftA, TRUE, 19, 20, timer, 4)
                    },
                    PL_ST_STAMP, bl {
                        @if timer < 2 bl {
                            ftA = 21
                        } .else bl {
                            easyAnimation(ftA, TRUE, 22, 23, timer, 2)
                        }
                    },
                    PL_ST_STAMP_EN, bl {
                        ftA = 29
                    },
                    PL_ST_DASH, bl {
                        easyAnimation(ftA, TRUE, 24, 27, timer, 2)
                    },
                    PL_ST_DASH_EN, bl {
                        ftA = 28
                    },
                    PL_ST_SLIP, bl {
                        easyAnimation(ftA, TRUE, 30, 31, timer, 2)
                    },
                    PL_ST_WALLRUN, bl {
                        easyAnimation(ftA, TRUE, 36, 39, timer, 2)
                    },
                    PL_ST_CLIFF, bl {
                        easyAnimation(ftA, TRUE, 34, 35, timer, 4)
                    },
                    PL_ST_DAMAGE, bl {
                        easyAnimation(ftA, TRUE, 32, 33, timer, 4)
                    }],
                    bl {}
                    )

                    cell = CH_CELL_PL + ftA

                    //無敵時間中は点滅する
                    @if `state != PL_ST_DAMAGE && param2 > 0 && param2 % 4 < 2 bl {
                        cell = 0
                    }

                    //向きによって追従キャラクタの位置をずらす
                    @if `!(bit & CH_BIT_HREV) && trailOffset < 100 bl {
                        trailOffset += TR_CH_OFFSET_SP
                    } .elif `(bit & CH_BIT_HREV) && trailOffset > -100 bl {
                        trailOffset -= TR_CH_OFFSET_SP
                    }
                },
                //----------------------------
                //オーク
                //上に剣を構えて左右を往復する
                CH_TYPE_EN_1, bl {
                    //向き
                    sgn = (bit & CH_BIT_HREV) ? -1 : 1
                    pseudoSwitchState(state, 
                    [CH_ST_ACTIVE, bl {
                        easyAnimation(ftA, TRUE, 0, 3, timer, 4)
                        cell = CH_CELL_EN_1 + ftA
                        //上に攻撃判定
                        _setAttackParam(ATK_EN_NORMAL, 0, 8, 16, -20, -45, UNIT_POS)
                        //ゆっくりと左右を往復する
                        @if `bit & CH_BIT_COLL_B bl {
                            //移動
                            _setCharaSpeed(1 * sgn * UNIT_POS, 2)
                            //壁に当たると反転する
                            @if `bit & CH_BIT_COLL_L bl {
                                bitOff(bit, CH_BIT_HREV)
                            } .elif `bit & CH_BIT_COLL_R bl {
                                bitOn(bit, CH_BIT_HREV)
                            }
                        }
                    },
                    EN_ST_DEFENSE, bl {
                        cell = CH_CELL_EN_1 + 4
                        //減速する
                        _setCharaSpeed(0, 2)
                        //後退する
                        @if timer == 1 bl {
                            vx = -3 * UNIT_POS * sgn
                        }
                        //通常状態に戻る
                        @if timer > 30 bl {
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    EN_ST_DAMAGE, bl {
                        cell = CH_CELL_EN_1 + 5
                        //後ろに跳ねる
                        @if timer == 0 bl {
                            bitOff(bit, CH_BIT_COLL_ATK | CH_BIT_COLL_MAP | CH_BIT_SLIDE)
                            V2_set(vx, -6 * UNIT_POS * sgn, -8 * UNIT_POS)
                        }
                    },
                    CH_ST_INIT, bl {
                        _setCharaStateTemp(CH_ST_ACTIVE)
                        bitOn(bit, CH_BIT_COLL_MAP | CH_BIT_GRAVITY | CH_BIT_SLIDE | CH_BIT_COLL_ATK | CH_BIT_COLL_STAMP | CH_BIT_SCREEN | CH_BIT_DIR_PL)
                    } ],
                    bl {}
                    )
                },
                //----------------------------
                //ビー
                //下に棘を構えて時計回りに円を描くように往復する。往復範囲は登場位置から下2マス分
                //p1:円軌道
                CH_TYPE_EN_2, bl {
                    //向き
                    sgn = (bit & CH_BIT_HREV) ? -1 : 1
                    pseudoSwitchState(state, 
                    [CH_ST_ACTIVE, bl {
                        easyAnimation(ftA, TRUE, 0, 1, timer, 4)
                        cell = CH_CELL_EN_2 + ftA
                        //下に攻撃判定
                        _setAttackParam(ATK_EN_NORMAL, 0, 16, 8, 0, 4, UNIT_POS)
                        //回るように移動する
                        V2_set(vx,
                            cos(param1, 1, 2 * UNIT_POS),
                            sin(param1, 1, 2 * UNIT_POS)
                        )
                        param1 = (param1 + 3) % 360
                    },
                    EN_ST_DEFENSE, bl {
                        cell = CH_CELL_EN_2 + 2
                        //停止する
                        V2_set(vx, 0, 0)
                        //通常状態に戻る
                        @if timer > 30 bl {
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    EN_ST_DAMAGE, bl {
                        cell = CH_CELL_EN_2 + 3
                        //後ろに跳ねる
                        @if timer == 0 bl {
                            bitOn(bit, CH_BIT_GRAVITY)
                            bitOff(bit, CH_BIT_COLL_ATK | CH_BIT_COLL_MAP | CH_BIT_SLIDE)
                            V2_set(vx, -6 * UNIT_POS * sgn, -4 * UNIT_POS)
                        }
                    },
                    CH_ST_INIT, bl {
                        _setCharaStateTemp(CH_ST_ACTIVE)
                        bitOn(bit, CH_BIT_COLL_MAP | CH_BIT_SLIDE | CH_BIT_COLL_ATK | CH_BIT_COLL_STAMP | CH_BIT_SCREEN | CH_BIT_DIR_PL)
                    } ],
                    bl {}
                    )
                },
                //----------------------------
                //ゴースト
                //地形を無視してゆっくりと接近する。数秒後に点滅して消える
                //p1:時間
                CH_TYPE_EN_3, bl {
                    //向き
                    sgn = (bit & CH_BIT_HREV) ? -1 : 1
                    pseudoSwitchState(state, 
                    [CH_ST_ACTIVE, bl {
                        easyAnimation(ftA, TRUE, 0, 3, timer, 4)
                        cell = CH_CELL_EN_3 + ftA
                        //中心下に小さな攻撃判定
                        _setAttackParam(ATK_EN_NORMAL, EN_ST_DEFENSE, 4, 4, 0, -24, UNIT_POS)
                        //ゆっくりと接近する
                        //負荷を軽減したいので数Fに一度判定する
                        @if `timer % 3 == 0 bl {
                            _getCharaPtr(pB, CH_ID_PLAYER)
                            V2_set(vx,
                                clamp((v[pB + MC_X] - px), -5, 5),
                                clamp((v[pB + MC_Y] - py), -5, 5)
                            )
                        }
                        //時間が経つと点滅し、消える
                        param1 -= 1
                        @if param1 <= 0 bl {
                            state = CH_ST_DELETE
                        } .elif `param1 < UNIT_FPS * 3 &&  param1 % 4 < 2 bl {
                            cell = 0
                        }
                    },
                    EN_ST_DEFENSE, bl {
                        cell = CH_CELL_EN_3 + 4
                        //停止する
                        V2_set(vx, 0, 0)
                        //後退する
                        @if timer == 1 bl {
                            vx = -3 * UNIT_POS * sgn
                        }
                        //通常状態に戻る
                        @if timer > 30 bl {
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    EN_ST_DAMAGE, bl {
                        cell = CH_CELL_EN_3 + 5
                        //後ろに跳ねる
                        @if timer == 0 bl {
                            bitOn(bit, CH_BIT_GRAVITY)
                            bitOff(bit, CH_BIT_COLL_ATK | CH_BIT_COLL_MAP)
                            V2_set(vx, -6 * UNIT_POS * sgn, -4 * UNIT_POS)
                        }
                    },
                    CH_ST_INIT, bl {
                        _setCharaStateTemp(CH_ST_ACTIVE)
                        bitOn(bit, CH_BIT_SCREEN | CH_BIT_COLL_ATK | CH_BIT_COLL_STAMP | CH_BIT_DIR_PL)
                        param1 = UNIT_FPS * 16
                    } ],
                    bl {}
                    )
                },
                //----------------------------
                //ジン
                //左右に追うように移動し、触れた氷を解かす。攻撃判定は左右と上に常にある
                CH_TYPE_EN_4, bl {
                    //向き
                    sgn = (bit & CH_BIT_HREV) ? -1 : 1
                    pseudoSwitchState(state, 
                    [CH_ST_ACTIVE, bl {
                        easyAnimation(ftA, TRUE, 0, 3, timer, 4)
                        cell = CH_CELL_EN_4 + ftA
                        //左右と上に大きな攻撃判定
                        _setAttackParam(ATK_EN_NORMAL, 0, 34, 16, 0, -36, UNIT_POS)
                        //プレイヤーを追って左右に移動する
                        _setCharaSpeed(2 * sgn * UNIT_POS, 1)
                        //0.5秒に1回、振り向き判定を行う
                        @if `timer % 30 == 0 bl {
                            bitOn(bit, CH_BIT_DIR_PL)
                        }
                    },
                    EN_ST_DEFENSE, bl {
                        cell = CH_CELL_EN_4 + 4
                        //停止する
                        V2_set(vx, 0, 0)
                        //通常状態に戻る
                        @if timer > 30 bl {
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    EN_ST_DAMAGE, bl {
                        cell = CH_CELL_EN_4 + 5
                        //後ろに跳ねる
                        @if timer == 0 bl {
                            bitOn(bit, CH_BIT_GRAVITY)
                            bitOff(bit, CH_BIT_COLL_ATK | CH_BIT_COLL_MAP | CH_BIT_SLIDE)
                            V2_set(vx, -6 * UNIT_POS * sgn, -4 * UNIT_POS)
                        }
                    },
                    CH_ST_INIT, bl {
                        _setCharaStateTemp(CH_ST_ACTIVE)
                        bitOn(bit, CH_BIT_COLL_MAP | CH_BIT_SCREEN | CH_BIT_COLL_ATK | CH_BIT_COLL_STAMP | CH_BIT_SLIDE | CH_BIT_DIR_PL | CH_BIT_MELT)
                    } ],
                    bl {}
                    )
                },
                //----------------------------
                //偽ゴメス
                //p1:行動パターン
                CH_TYPE_EN_BOSS_1, bl {
                    //行動制御用
                    iptSgn = 0
                    //向き
                    sgn = (bit & CH_BIT_HREV) ? -1 : 1
                    //地面にいると減速する
                    @if `bit & CH_BIT_COLL_B bl {
                        _setCharaSpeed(0, 2)
                    }
                    pseudoSwitchState(state, 
                    [CH_ST_ACTIVE, bl {
                        @if `bit & CH_BIT_COLL_B bl {
                            easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+2, CH_CELL_EN_BOSS+3, timer, 4)
                        } .else bl {
                            cell = CH_CELL_EN_BOSS+0
                        }
                        //振り向き
                        bitOn(bit, CH_BIT_DIR_PL)
                        //地上にいて、プレイヤーとの距離が近すぎる場合はジャンプで逃げる
                        @if timer == 1 bl {
                            _getCharaPtr(pB, CH_ID_PLAYER)
                            @if `(bit & CH_BIT_COLL_B) && abs(px - v[pB + MC_X]) < 90 * UNIT_POS bl {
                                _setCharaStateTemp(BO_ST_ESCAPE)
                            }
                        }
                        //次の行動
                        //第二形態だと行動が早くなる
                        @if `timer > 60 || (bossHp <= BOSS_PHASE && timer > 30) bl {
                            iptSgn = 1
                            timer = 0
                        }
                    },
                    //怯む
                    EN_ST_DEFENSE, bl {
                        cell = CH_CELL_EN_BOSS + 6
                        //通常状態に戻る
                        @if timer > 40 bl {
                            bitOff(bit, CH_BIT_COLL_ATK)
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    //ダメージ
                    EN_ST_DAMAGE, bl {
                        @if bossHp > BOSS_PHASE bl {
                            //吹っ飛ぶ
                            @if timer == 0 bl {
                                cell = CH_CELL_EN_BOSS + rnd(7, 9)
                                V2_set(vx, -7 * UNIT_POS * sgn, -4 * UNIT_POS)
                                bitOff(bit, CH_BIT_COLL_ATK)
                                //HP減少と行動パターンの初期化
                                bossHp -= 1
                                param1 = 0

                                //次の形態へ移行する
                                @if bossHp <= BOSS_PHASE bl {
                                    _setCharaStateTemp(BO_ST_EVENT_CH)
                                }
                            }
                            //壁に当たると反射する
                            @if `(sgn < 0 && (bit & CH_BIT_COLL_R)) || (sgn > 0 && (bit & CH_BIT_COLL_L)) bl {
                                vx = 2 * UNIT_POS * sgn
                            }
                            //復帰
                            @if timer > 40 bl {
                                _setCharaStateTemp(BO_ST_RECOVER)
                            }
                        //第二形態になると怯まなくなる
                        } .else bl {
                            easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+0, CH_CELL_EN_BOSS+1, timer, 4)
                            @if timer == 0 bl {
                                @se.play "Sword2" .opt(80, 120, 50)
                                bitOff(bit, CH_BIT_COLL_ATK)
                            }
                            //復帰
                            @if timer > 40 bl {
                                _setCharaStateTemp(CH_ST_ACTIVE)
                            }
                        }
                    },
                    //移動する
                    BO_ST_ESCAPE, bl {
                        easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+10, CH_CELL_EN_BOSS+11, timer, 2)
                        @if timer == 1 bl {
                            @se.play "Wind3" .opt(80, 120, 50)
                            V2_set(vx, 6 * UNIT_POS * sgn, -4 * UNIT_POS)
                        }
                        @if timer > 40 bl {
                            iptSgn = 1
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    //復帰する
                    BO_ST_RECOVER, bl {
                        easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+10, CH_CELL_EN_BOSS+11, timer, 2)
                        @if timer == 1 bl {
                            @se.play "Wind3" .opt(80, 120, 50)
                        }
                        @if timer > 20 bl {
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    //ダッシュ攻撃
                    BO_ST_DASH, bl {
                        //構え
                        @if timer < 30 bl {
                            cell = CH_CELL_EN_BOSS + 12
                            @if timer == 1 bl {
                                V2_set(vx, sgn * -4 * UNIT_POS, 0)
                            }
                        //加速
                        } .else bl {
                            easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+13, CH_CELL_EN_BOSS+14, timer, 2)
                            _setCharaSpeed(sgn * 12 * UNIT_POS, 10)
                            _setAttackParam(ATK_EN_NORMAL, 0, 8, 20, 20, -24, UNIT_POS)
                            @if timer == 30 bl {
                                @se.play "Wind9" .opt(90, 120, 50)
                            }
                            @if `(sgn > 0 && (bit & CH_BIT_COLL_R)) || (sgn < 0 && (bit & CH_BIT_COLL_L)) bl {
                                iptSgn = 2
                                _setCharaStateTemp(BO_ST_DASH_EN)
                                @scr.shake .once(1) .value(2, 9)
                                @se.play "punch2" .opt(80, 100, 50)
                            }
                        }
                    },
                    //ダッシュ攻撃終わり
                    //攻撃の隙ができる
                    BO_ST_DASH_EN, bl {
                        easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+15, CH_CELL_EN_BOSS+16, timer, 4)
                        @if timer == 1 bl {
                            V2_set(vx, sgn * -3 * UNIT_POS, -4 * UNIT_POS)
                            bitOn(bit, CH_BIT_COLL_ATK)
                        }
                        @if timer > 60 bl {
                            bitOff(bit, CH_BIT_COLL_ATK)
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    //メタルマン
                    BO_ST_METAL, bl {
                        //構え
                        @if timer <= 12 bl {
                            cell = CH_CELL_EN_BOSS + 17
                            @if timer == 12 bl {
                                V2_set(vx, sgn * 3 * UNIT_POS, -11 * UNIT_POS)
                            }
                        //ジャンプ
                        } .elif timer <= 35 bl {
                            cell = CH_CELL_EN_BOSS + 18
                            @if timer == 35 bl {
                                @se.play "jump_anim" .opt(70, 140, 50)
                                _setShootParam(CH_TYPE_EN_BOSS_ATK_1, SHT_TO_PL, 8, -8, 8, 0, UNIT_POS)
                                vy = -2 * UNIT_POS
                            }
                        //落下
                        } .else bl {
                            cell = CH_CELL_EN_BOSS + 19
                            @if `bit & CH_BIT_COLL_B bl {
                                iptSgn = 2
                                _setCharaStateTemp(CH_ST_ACTIVE)
                            }
                        }
                    },
                    //勇者的な魔法
                    BO_ST_SHOOT, bl {
                        easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+20, CH_CELL_EN_BOSS+21, timer, 4)
                        @if timer == 1 bl {
                            @se.play "Wave2" .opt (70, 120, 50)
                        }
                        @if timer >= 120 bl {
                            iptSgn = 2
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        } .elif `timer > 0 && !(timer % 30) bl {
                            _setShootParam(CH_TYPE_EN_BOSS_ATK_1, SHT_TO_PL, 0, -56, 8, 0, UNIT_POS)
                        }
                    },
                    //瞬間移動
                    BO_ST_STAMP, bl {
                        @if timer < 12 bl {
                            easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+10, CH_CELL_EN_BOSS+11, timer, 2)
                            @if timer == 1 bl {
                                @se.play "Fire1" .opt(80, 150, 50)
                            }
                        } .elif timer < 35 bl {
                            easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+0, CH_CELL_EN_BOSS+1, timer, 4)
                            @if timer == 12 bl {
                                //プレイヤーの真上に移動
                                _getCharaPtr(pB, CH_ID_PLAYER)
                                V2_set(px, v[pB + MC_X], py - 3 * TILE_SIZE_PX * UNIT_POS)
                                V2_set(vx, 0, 0)
                                //重力OFF
                                bitOff(bit, CH_BIT_GRAVITY)
                                //煙エフェクト
                                _addEffect(bl {
                                    $type = EFF_TYPE_COMMON
                                    $cell = 9
                                    $scale = 125
                                    $x = px / UNIT_POS
                                    $y = py / UNIT_POS - 32
                                } )
                            }
                        } .else bl {
                            cell = CH_CELL_EN_BOSS + 25
                            //落下
                            @if timer == 35 bl {
                                vy = 16 * UNIT_POS
                                //重力ON
                                bitOn(bit, CH_BIT_GRAVITY)
                            }
                            //攻撃判定
                            _setAttackParam(ATK_EN_NORMAL, 0, 24, 6, 0, -20, UNIT_POS)
                            @if `bit & CH_BIT_COLL_B bl {
                                iptSgn = 2
                                _setCharaStateTemp(BO_ST_STAMP_EN)
                                //煙エフェクト
                                _addEffect(bl {
                                    $type = EFF_TYPE_COMMON
                                    $cell = 5
                                    $scale = 100
                                    $x = px / UNIT_POS
                                    $y = py / UNIT_POS - CH_PIC_SIZE / 2
                                } )
                                @scr.shake .once(1) .value(2, 9)
                                @se.play "punch2" .opt(80, 100, 50)
                            }
                        }
                    },
                    //瞬間移動終わり
                    BO_ST_STAMP_EN, bl {
                        easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+24, CH_CELL_EN_BOSS+25, timer, 4)
                        @if timer == 1 bl {
                            bitOn(bit, CH_BIT_COLL_ATK)
                        }
                        @if timer > 40 bl {
                            bitOff(bit, CH_BIT_COLL_ATK)
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    //戦闘開始前
                    BO_ST_EVENT, bl {
                        easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+0, CH_CELL_EN_BOSS+1, timer, 4)
                        //シグナルを受け取ると起動する
                        @if `bit & CH_BIT_SIGNAL bl {
                            bitOff(bit, CH_BIT_SIGNAL)
                            //重力ON
                            bitOn(bit, CH_BIT_GRAVITY)
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    //アレックスを起動する
                    BO_ST_EVENT_CH, bl {
                        @if timer < 60 bl {
                            easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+0, CH_CELL_EN_BOSS+1, timer, 4)
                        } .else bl {
                            easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+4, CH_CELL_EN_BOSS+5, timer, 4)
                        }
                        //上空に移動
                        @if timer == 1 bl {
                            V2_set(px, (4 * TILE_SIZE_PX) * UNIT_POS, 5 * TILE_SIZE_PX * UNIT_POS)
                            V2_set(vx, 0, 0)
                            bitOff(bit, CH_BIT_GRAVITY | CH_BIT_COLL_ATK)
                            @scr.flash .once(2) .rgbv(31, 31, 31, 24)
                        }
                        //チャージ
                        @if timer == 60 bl {
                            @se.play "Fog2" .opt(80, 120, 50)
                        }
                        //戻る
                        @if timer >= 150 bl {
                            _setCharaStateTemp(CH_ST_ACTIVE)
                            bitOn(bit, CH_BIT_GRAVITY)
                            //起動する
                            _getCharaPtr(pB, CH_ID_ALEX)
                            v[pB + MC_BIT] |= CH_BIT_SIGNAL
                            @se.play "Thunder10" .opt(80, 100, 50)
                            @scr.flash .once(2) .rgbv(31, 31, 31, 24)
                        }
                    },
                    CH_ST_INIT, bl {
                        _setCharaStateTemp(BO_ST_EVENT)
                        bitOn(bit, CH_BIT_COLL_MAP | CH_BIT_SLIDE | CH_BIT_DIR_PL | CH_BIT_COLL_HEAVY | CH_BIT_COLL_STAMP)
                        bossHp = BOSS_HP
                    } ],
                    bl {}
                    )

                    //行動制御
                    //1:待機直後 2:連続行動
                    @if iptSgn > 0 bl{
                        //玉投げと突進を交互に
                        @if bossHp == BOSS_HP bl {
                            ftA = [BO_ST_DASH, 0, BO_ST_METAL][param1 % 3]
                        //玉投げx2,突進往復
                        } .elif bossHp == BOSS_HP - 1 bl {
                            ftA = [BO_ST_METAL, BO_ST_METAL, BO_ST_DASH, BO_ST_DASH, 0][param1 % 5]
                        //魔法,突進往復
                        } .elif bossHp == BOSS_HP - 2 bl {
                            ftA = [BO_ST_SHOOT, BO_ST_DASH, BO_ST_DASH, BO_ST_DASH, 0][param1 % 5]
                        //突進,玉投げ,魔法,玉投げ,突進
                        } .elif bossHp == BOSS_HP - 3 bl {
                            ftA = [BO_ST_DASH, BO_ST_METAL, BO_ST_SHOOT, BO_ST_METAL, BO_ST_DASH, 0][param1 % 6]
                        //瞬間移動,待機,突進,瞬間移動
                        } .elif bossHp == BOSS_HP - 4 bl {
                            ftA = [BO_ST_STAMP, 0, BO_ST_DASH, BO_ST_STAMP, 0][param1 % 5]
                        //瞬間移動,魔法,瞬間移動x2
                        } .elif bossHp == BOSS_HP - 5 bl {
                            ftA = [BO_ST_STAMP, BO_ST_SHOOT, BO_ST_STAMP, BO_ST_STAMP, 0][param1 % 5]
                        //単発行動
                        } .else bl {
                            ftA = [BO_ST_DASH, 0, BO_ST_METAL, 0, BO_ST_STAMP, 0, BO_ST_SHOOT, 0][param1 % 8]
                        }
                        //適用する
                        @if ftA > 0 bl {
                            bitOn(bit, CH_BIT_DIR_PL)
                            _setCharaStateTemp(ftA)
                        }
                        //次のパターン
                        param1 += 1
                    }
                },
                //ボスの飛び道具
                CH_TYPE_EN_BOSS_ATK_1, bl {
                    @if state == CH_ST_INIT bl {
                        state = CH_ST_ACTIVE
                        bitOn(bit, CH_BIT_SCREEN)
                    }
                    easyAnimation(cell, TRUE, CH_CELL_EN_BOSS+22, CH_CELL_EN_BOSS+23, timer, 2)
                    _setAttackParam(ATK_EN_NORMAL, 0, 8, 8, 0, -16, UNIT_POS)
                },
                //----------------------------
                //アレックス
                //p1:横の移動速度
                CH_TYPE_EN_BOSS_ALEX, bl {
                    //向き
                    sgn = (bit & CH_BIT_HREV) ? -1 : 1
                    //常に減速する
                    _setCharaSpeed(0, 1)
                    //縦速度も
                    vy /= 2
                    pseudoSwitchState(state,
                    [CH_ST_ACTIVE, bl {
                        easyAnimation(cell, TRUE, CH_CELL_ALEX+2, CH_CELL_ALEX+3, timer, 12)
                        //当たり判定
                        @if timer == 1 bl {
                            bitOn(bit, CH_BIT_COLL_ATK)
                        }
                    },
                    //ダメージを受けると横に吹っ飛ぶ
                    EN_ST_DAMAGE, bl {
                        cell = CH_CELL_ALEX + 4
                        @if timer == 0 bl {
                            @if bossHp > 1 bl {
                                V2_set(vx, -7 * UNIT_POS * sgn, 0)
                                bitOff(bit, CH_BIT_COLL_ATK)
                                bossHp -= 1
                                //横の移動量を保存する
                                param1 = vx
                            } .else bl {
                                //ボスの体力が尽きると演出に移行する
                                _pushEvents(TRUE, TRUE, EVENT_CND_DEFEATED_BOSS)
                            }
                        }
                        //壁に当たると反射する
                        @if `(sgn < 0 && (bit & CH_BIT_COLL_R)) || (sgn > 0 && (bit & CH_BIT_COLL_L)) bl {
                            vx = -param1
                        }
                        //横の移動量を更新する
                        param1 = vx
                        //復帰
                        @if timer > 40 bl {
                            bitOn(bit, CH_BIT_COLL_ATK)
                            _setCharaStateTemp(CH_ST_ACTIVE)
                        }
                    },
                    //待機
                    BO_ST_EVENT, bl {
                        easyAnimation(cell, TRUE, CH_CELL_ALEX+0, CH_CELL_ALEX+1, timer, 12)
                        //シグナルを受け取ると起動する
                        @if `bit & CH_BIT_SIGNAL bl {
                            bitOff(bit, CH_BIT_SIGNAL)
                            _setCharaStateTemp(CH_ST_ACTIVE)
                            //少し上に退避する
                            vy -= 15 * UNIT_POS
                        }
                    },
                    CH_ST_INIT, bl {
                        bitOn(bit, CH_BIT_SLIDE | CH_BIT_COLL_MAP | CH_BIT_COLL_HEAVY)
                        _setCharaStateTemp(BO_ST_EVENT)
                    } ] )
                },
                //----------------------------
                //イベント用
                CH_TYPE_EVENT, bl {
                } ],
                bl {}
                )
                //----------------------------
                //速度を徐々に変える
                @if `bit & CH_BIT_SLIDE bl {
                    @if `accVx bl {
                        @if `between(tagVx - vx, -accVx, accVx) bl {
                            vx = tagVx
                        } .else bl {
                            vx += (vx < tagVx) ? (accVx) : (-accVx)
                        }
                    }
                }
                //----------------------------
                //重力
                @if `bit & CH_BIT_GRAVITY bl {
                    vy = min(vy + CH_GRAVITY, CH_MAX_SPEED * UNIT_POS)
                }
                //----------------------------
                //射撃(イベント中は無効)
                @if `shtType > SHT_NONE && !IN_EVENT bl {
                    //向き
                    @if `bit & CH_BIT_HREV bl {
                        shtX *= -1
                    }
                    //速度
                    //プレイヤーに向ける
                    //vxは速度として扱われる
                    @if shtType == SHT_TO_PL bl {
                        _getCharaPtr(pB, CH_ID_PLAYER)
                        ftA = atan2( v[pB + MC_Y] - (py + shtY), v[pB + MC_X] - (px + shtX), 10)
                        V2_getCosSin(ax, ftA, 10, shtVx)
                    } .else bl {
                        V2_set(ax, 0, 0)
                    }
                    //空きを探す
                    @loop CH_NUM .dst(iB) bl {
                        _getCharaPtr(pB, iB)
                        @if `v[pB + MC_STATE] > CH_ST_NONE bl {
                            @continue
                        }
                        _initChara(pB, bl {
                            $type = shtChara
                            $state = CH_ST_INIT
                            $id = -1
                            $x = px + shtX
                            $y = py + shtY
                            $vx = ax
                            $vy = ay
                        } )
                        @break
                    }
                }
                //----------------------------
                //攻撃(イベント中は無効)
                @if `atkType > ATK_NONE && !IN_EVENT bl {
                    //向き
                    @if `bit & CH_BIT_HREV bl {
                        atkX *= -1
                    }
                    @loop CH_NUM .dst(iB) bl {
                        _getCharaPtr(pB, iB)
                        //キャラが存在しない or 初期化前
                        @if `v[pB + MC_STATE] <= CH_ST_INIT bl {
                            @continue
                        }

                        //敵からプレイヤーへの攻撃判定
                        //無敵モードになっているときは無視する
                        @if `atkType == ATK_EN_NORMAL && (iB != CH_ID_PLAYER || invincibleSwitch) bl {
                            @continue
                        //プレイヤーから敵への攻撃判定
                        } .elif `between(atkType, ATK_PL_FALL, ATK_PL_STAMP) && iB == CH_ID_PLAYER bl {
                            @continue
                        }

                        //被攻撃フラグ
                        atkedType = v[pB + MC_BIT] & CH_BIT_COLL_ATK
                        //被攻撃フラグが立っていない
                        @if `!atkedType bl {
                            @continue
                        }
                        //矩形同士の衝突判定
                        V2_set(ax,
                            v[pB + MC_X],
                            v[pB + MC_Y]
                        )
                        @if `(px + atkX + atkHw < ax - CH_HIT_LR * UNIT_POS || ax + CH_HIT_LR * UNIT_POS < px + atkX - atkHw) ||
                             (py + atkY + atkHh < ay + CH_HIT_T  * UNIT_POS || ay + CH_HIT_B  * UNIT_POS < py + atkY - atkHh ) bl {
                            @continue
                        }
                        //怯みの方向
                        iptSgn = (v[pB + MC_X] < px) ? 1 : -1
                        //相手の向きを修正する
                        ftB = v[pB + MC_BIT]
                        @if iptSgn > 0 bl {
                            bitOff(ftB, CH_BIT_HREV)
                        } .else bl {
                            bitOn(ftB, CH_BIT_HREV)
                        }
                        v[pB + MC_BIT] = ftB
                        //衝突時の処理
                        pseudoSwitchState(atkType,
                        //----------------------------
                        //プレイヤーの踏みつけ判定
                        [ATK_PL_FALL, bl {
                            @if `v[pB + MC_BIT] & CH_BIT_COLL_STAMP bl {
                                //敵を怯ませる
                                _setCharaState(pB, EN_ST_DEFENSE)
                                //ジャンプ
                                _setCharaStateTemp(PL_ST_JUMP)
                                //ジャンプボタンを押すと上昇力が変わる
                                vy = (inputD > 0 ? 7 : 5) * -1 * UNIT_POS
                                @se.play "Barrier1" .opt(100, 120, 50)
                            }
                        },
                        //----------------------------
                        ATK_PL_DASH, bl {
                            //敵が重かった場合、後ろに跳ねる
                            @if `v[pB + MC_BIT] & CH_BIT_COLL_HEAVY bl {
                                atkState = PL_ST_DASH_EN
                                V2_set(vx, -2 * UNIT_POS * sgn, -3 * UNIT_POS)
                            }
                            //敵を吹っ飛ばす
                            _setCharaState(pB, EN_ST_DAMAGE)
                            //ヒットエフェクト
                            //少し上に寄せる
                            V2_set(bx,
                                rnd(-8, 8),
                                rnd(-8, 8) - 4
                            )
                            _addEffect(bl {
                                $type = EFF_TYPE_COMMON
                                $cell = 13
                                $scale = 100
                                $x = (px + atkX) / UNIT_POS + bx
                                $y = (py + atkY) / UNIT_POS + by
                            } )
                            //ヒットストップ
                            stopTimer = 4
                            @scr.shake .once(1) .value(1, 9)
                            @se.play "Damage1" .opt(100, 100, 50)
                        },
                        //----------------------------
                        ATK_PL_STAMP, bl {
                            //敵を吹っ飛ばす
                            _setCharaState(pB, EN_ST_DAMAGE)
                            //ジャンプ
                            @if inputD > 0 bl {
                                //ジャンプボタンを押すとハイジャンプになる
                                _setCharaStateTemp(PL_ST_HIJUMP)
                                vy = -10 * UNIT_POS
                            } .else bl {
                                _setCharaStateTemp(PL_ST_JUMP)
                                vy = -7 * UNIT_POS
                            }
                            //ヒットエフェクト
                            V2_set(bx,
                                rnd(-8, 8),
                                rnd(-8, 8)
                            )
                            _addEffect(bl {
                                $type = EFF_TYPE_COMMON
                                $cell = 13
                                $scale = 100
                                $x = (px + atkX) / UNIT_POS + bx
                                $y = (py + atkY) / UNIT_POS + by
                            } )
                            //ヒットストップ
                            stopTimer = 8
                            @scr.shake .once(1) .value(1, 9)
                            @se.play "Damage1" .opt(100, 100, 50)
                        },
                        //----------------------------
                        //敵の通常攻撃判定
                        ATK_EN_NORMAL, bl {
                            //プレイヤー被弾
                            _setCharaState(pB, PL_ST_DAMAGE)
                            //後ろに跳ねる
                            v[pB + MC_VX] = PL_KNOCKBACK_VX * iptSgn * UNIT_POS
                            v[pB + MC_VY] = PL_KNOCKBACK_VY * UNIT_POS
                            //無敵時間
                            v[pB + MC_PM_2] = PL_INV_TIMER
                            //ダメージカウント
                            damageCnt += 1
                            //ヒットストップ
                            stopTimer = 2
                            @se.play "Damage2" .opt(100, 100, 50)
                        } ],
                        bl {}
                        )
                        //攻撃者側の状態遷移
                        @if atkState > CH_ST_NONE bl {
                            _setCharaStateTemp(atkState)
                        }
                    }
                }
                //----------------------------
                //プレイヤーの方向へ一度だけ振り向く
                @if `bit & CH_BIT_DIR_PL bl {
                    bitOff(bit, CH_BIT_DIR_PL)

                    _getCharaPtr(pB, CH_ID_PLAYER)
                    iptSgn = (v[pB + MC_X] < px) ? 1 : -1

                    @if iptSgn > 0 bl {
                        bitOn(bit, CH_BIT_HREV)
                    } .else bl {
                        bitOff(bit, CH_BIT_HREV)
                    }
                }
                //----------------------------
                //画面外に出ると消える
                @if `bit & CH_BIT_SCREEN bl {
                    V2_divScalar(ax, px, UNIT_POS)
                    @if `!(between(ax,scrX - SCREEN_OUT_X, scrX + WINDOW_WIDTH + SCREEN_OUT_X) && between(ay, scrY - SCREEN_OUT_Y, scrY + WINDOW_HEIGHT + SCREEN_OUT_Y)) bl {
                        _setCharaStateTemp(CH_ST_DELETE)
                    }
                }
                //----------------------------
                //変数を更新する
                v[pA + MC_STATE] = state
                v[pA + MC_TIMER] = timer
                v[pA + MC_CELL] = cell
                v[pA + MC_BIT] = bit
                v[pA + MC_PM_1] = param1
                v[pA + MC_PM_2] = param2
                v[pA + MC_X] = px
                v[pA + MC_Y] = py
                v[pA + MC_VX] = vx
                v[pA + MC_VY] = vy
                //----------------------------
                //ピクチャを更新する
                pid = PIC_CHARA + iA
                V2_set(ax,
                    px / UNIT_POS - scrX,
                    py / UNIT_POS - scrY
                )
                @if `bit & CH_BIT_HREV bl {
                    @pic.show[pid] .pos(ax, ay) .cell(cell) .hrev charaPicCmd
                } .else bl {
                    @pic.show[pid] .pos(ax, ay) .cell(cell) charaPicCmd
                }
            }
            //----------------------------
            //キャラクターは干渉を受けて状態を変える為、すぐには消えない
            //消去が予約されているキャラクターを一括で消去する
            @loop CH_NUM .dst(iA) bl {
                _getCharaPtr(pA, iA)
                state = v[pA + MC_STATE]
                //何もしない
                @if state <= CH_ST_NONE bl {
                    @continue
                }
                //消去する                
                @if state == CH_ST_DELETE bl {
                    pid = PIC_CHARA + iA
                    _initChara(pA, bl {
                        $state = CH_ST_NONE
                    } )
                    @pic.show[pid] .pos(OUT_RANGE, OUT_RANGE) .trans(100) .cell(0) charaPicCmd
                }
            }
            //----------------------------
            // NPCキャラクター
            @loop NPC_NUM .dst(iA) bl {
                _getNpcPtr(pA, iA)
                @if `v[pA + MN_STATE] <= NPC_ST_NONE bl {
                    @continue
                }
                //----------------------------
                //タイマー
                v[pA + MN_TIMER] += 1
                //----------------------------
                //一時変数
                type  = v[pA + MN_TYPE]
                state = v[pA + MN_STATE]
                timer = v[pA + MN_TIMER]
                bit = v[pA + MN_BIT]
                cell = v[pA + MN_CELL]
                param1 = v[pA + MN_PM_1]
                V2_set(px, v[pA + MN_X],  v[pA + MN_Y])
                //----------------------------
                pseudoSwitchState(type,
                //操作説明を表示する p1:パターン
                [NPC_TYPE_TUTORIAL, bl {
                    easyAnimation(cell, TRUE, 0, 1, timer, 6)
                    cell += NPC_CELL_TUTORIAL + param1 * 2
                    //プレイヤーとの距離
                    _getCharaPtr(pB, CH_ID_PLAYER)
                    V2_set(ax, v[pB + MC_X] - px, v[pB + MC_Y] - py)

                    pseudoSwitchState(state,
                    [NPC_ST_WAIT, bl {
                        //プレイヤーが近づくと起動する
                        $L = 48 * UNIT_POS
                        @if `abs(ax) < $L && abs(ay) < $L bl {
                            _setNpcStateTemp(NPC_ST_ACTIVE)
                            ftA = param1 + 1
                            @pic.show [PIC_TUTORIAL] .pos(WINDOW_WIDTH/2, -80) .cell(ftA) tutorialPicCmd
                            @pic.move [PIC_TUTORIAL] .relative .pos(0, 100) .time(2)
                            @se.play "voice_ieeei2" .opt(60, 120, 50)
                        }
                    },
                    NPC_ST_ACTIVE, bl {
                        //プレイヤーが遠ざかると閉じる
                        $L = 64 * UNIT_POS
                        @if `abs(ax) < $L && abs(ay) < $L bl {
                        } .else bl {
                            _setNpcStateTemp(NPC_ST_WAIT)
                            @pic.move [PIC_TUTORIAL] .relative .pos(0, -100) .trans(100) .time(2)
                        }
                    },
                    NPC_ST_INIT, bl {
                        bitOn(bit, NPC_BIT_SCREEN)
                        _setNpcStateTemp(NPC_ST_WAIT)
                    } ],
                    bl {}
                    )  
                },
                //プレイヤーを追従する p1:キャラ
                NPC_TYPE_CHASE, bl {
                    pseudoSwitchState(state,
                    [NPC_ST_WAIT, bl {
                        easyAnimation(cell, TRUE, 0, 1, timer, 6)
                        cell += NPC_CELL_CHASE + param1 * 8
                        //プレイヤーが近づくと起動する
                        $L = 64 * UNIT_POS
                        _getCharaPtr(pB, CH_ID_PLAYER)
                        V2_set(ax, v[pB + MC_X] - px, v[pB + MC_Y] - py)
                        @if `abs(ax) < $L && abs(ay) < $L bl {
                            //起動すると画面外に出ても消えない
                            bitOff(bit, NPC_BIT_SCREEN)
                            _setNpcStateTemp(NPC_ST_ACTIVE)
                            @se.play "Item1" .opt(80, 120, 50)
                        }
                    },
                    NPC_ST_ACTIVE, bl {
                        easyAnimation(cell, TRUE, 2, 7, timer, 6)
                        cell += 1 + param1 * 8
                        //軌跡をなぞる
                        ftA = trailIdx - param1 * TR_CH_INTERVAL + TR_NUM
                        cx = v[__id(trailHead) + (ftA - 1) % TR_NUM]
                        cy = v[__id(trailHead) + (ftA - 0) % TR_NUM]
                        V2_set(ax, cx & 0xffff, (cx >> 16) & 0xffff)
                        V2_set(bx, cy & 0xffff, (cy >> 16) & 0xffff)
                        //目標位置
                        V2_set(cx,
                            lerp(ax, bx, trailCnt, TR_INTERVAL) + muldiv(trailOffset, -1 * ((param1 + 1) * TR_CH_OFFSET + 8), 100),
                            lerp(ay, by, trailCnt, TR_INTERVAL)
                        )
                        V2_asMulScalar(cx, UNIT_POS)
                        //向きを変える
                        sgn = cx - px
                        @if sgn > 0 bl {
                            bitOff(bit, NPC_BIT_HREV)
                        } .elif sgn < 0 bl {
                            bitOn(bit, NPC_BIT_HREV)
                        }
                        //移動する
                        ftA = muldiv(min(timer, 20), 100, 20)
                        V2_set(px,
                            lerp(px, cx, ftA, 100),
                            lerp(py, cy, ftA, 100)
                        )
                    },
                    NPC_ST_INIT, bl {
                        bitOn(bit, NPC_BIT_SCREEN)
                        _setNpcStateTemp(NPC_ST_WAIT)
                    } ],
                    bl {}
                    )
                },
                //入口
                //何もしない扉を設置する
                NPC_TYPE_GATE, bl {
                    cell = NPC_CELL_GATE
                    @if state == NPC_ST_INIT bl {
                        bitOn(bit, NPC_BIT_SCREEN)
                        _setNpcStateTemp(NPC_ST_WAIT)
                    }
                },
                //ゴール
                //近寄ると次のステージへ移行する
                NPC_TYPE_GOAL, bl {
                    @if state == NPC_ST_INIT bl {
                        //最終ステージは扉の外見になる
                        cell = [0,0,NPC_CELL_GOAL][stageNumber]
                        _setNpcStateTemp(NPC_ST_WAIT)
                    } .else bl {
                        //プレイヤーが近づくと起動する
                        $L = 32 * UNIT_POS
                        _getCharaPtr(pB, CH_ID_PLAYER)
                        V2_set(ax, v[pB + MC_X] - px, v[pB + MC_Y] - py)
                        @if `!IN_EVENT && abs(ax) < $L && abs(ay) < $L bl {
                            _pushEvents(FALSE, TRUE, EVENT_CMD_GOAL)
                        }
                    }
                } ],
                bl {}
                )
                //----------------------------
                //画面外に出ると消える
                @if `bit & NPC_BIT_SCREEN bl {
                    V2_divScalar(ax, px, UNIT_POS)
                    @if `!(between(ax,scrX - SCREEN_OUT_X, scrX + WINDOW_WIDTH + SCREEN_OUT_X) && between(ay, scrY - SCREEN_OUT_Y, scrY + WINDOW_HEIGHT + SCREEN_OUT_Y)) bl {
                        _setNpcStateTemp(NPC_ST_NONE)
                    }
                }
                //----------------------------
                //変数を更新する
                v[pA + MN_STATE] = state
                v[pA + MN_TIMER] = timer
                v[pA + MN_BIT] = bit
                v[pA + MN_CELL] = cell
                v[pA + MN_PM_1] = param1
                v[pA + MN_X] = px
                v[pA + MN_Y] = py
                //----------------------------
                //表示
                pid = PIC_NPC + iA
                //消去する
                @if `state <= NPC_ST_NONE bl {
                    @pic.show[pid] .pos(OUT_RANGE, OUT_RANGE) .trans(100) .cell(0) npcPicCmd
                //ピクチャを更新する
                } .else bl {
                    V2_set(ax,
                        px / UNIT_POS - scrX,
                        py / UNIT_POS - scrY
                    )
                    @if `bit & NPC_BIT_HREV bl {
                        @pic.show[pid] .pos(ax, ay) .cell(cell) .hrev npcPicCmd
                    } .else bl {
                        @pic.show[pid] .pos(ax, ay) .cell(cell) npcPicCmd
                    }
                }
            }
            //----------------------------
            //エフェクト
            @loop EFF_NUM .dst(iA) bl {
                _getEffectPtr(pA, iA)
                @if `v[pA + ME_TYPE] <= EFF_TYPE_NONE bl {
                    @continue
                }
                //----------------------------
                //一時変数
                type = v[pA + ME_TYPE]
                timer = v[pA + ME_TIMER]
                cell = v[pA + ME_CELL]
                scale = v[pA + ME_SCALE]
                V2_set(px,
                    v[pA + ME_X],
                    v[pA + ME_Y]
                )
                //----------------------------
                pseudoSwitchState(type,
                //汎用エフェクト
                //速さも枚数も同じ
                [EFF_TYPE_COMMON, bl {
                    $C = 4
                    $F = 2
                    //タイマー
                    timer += 1
                    //消去
                    @if `timer >= $C*$F bl {
                        type = EFF_TYPE_NONE
                    //次のパターン
                    } .elif `timer > 0 && timer % $F == 0 bl {
                        cell += 1
                    }
                },
                //扉 プレイヤーの状態を見て吹っ飛ぶ
                EFF_TYPE_GATE, bl {
                    cell = EFF_CELL_GATE + 0
                    _getCharaPtr(pB, CH_ID_PLAYER)
                    ftA = v[pB + MC_STATE]
                    @if ftA != PL_ST_EVENT bl {
                        timer += 1
                        //移動
                        px += 16
                        py -= 16
                        //一定時間後に消滅する
                        @if timer > 16 bl {
                            type = EFF_TYPE_NONE
                        }
                    }
                } ],
                bl {}
                )
                //----------------------------
                //変数を更新する
                v[pA + ME_TYPE] = type
                v[pA + ME_TIMER] = timer
                v[pA + ME_CELL] = cell
                v[pA + ME_SCALE] = scale
                v[pA + ME_X] = px
                v[pA + ME_Y] = py
                //----------------------------
                //表示
                pid  = PIC_EFFECT + iA
                //消去する
                @if `type <= EFF_TYPE_NONE bl {
                    @pic.show[pid] .pos(OUT_RANGE, OUT_RANGE) .trans(100) .cell(0) effectPicCmd
                //ピクチャを更新する
                } .else bl {
                    V2_set(ax,
                        v[pA + ME_X] - scrX,
                        v[pA + ME_Y] - scrY
                    )
                    //拡大率が負数だと左右反転する
                    @if scale < 0 bl {
                        ftA = -scale
                        @pic.show[pid] .pos(ax, ay) .scale(ftA) .cell(cell) .hrev effectPicCmd
                    } .else bl {
                        ftA = scale
                        @pic.show[pid] .pos(ax, ay) .scale(ftA) .cell(cell) effectPicCmd
                    }
                }
            }
            //----------------------------
            //軌跡の座標を更新する
            trailCnt += 1
            @if trailCnt >= TR_INTERVAL bl {
                trailCnt = 0
                trailIdx += 1
                @if trailIdx >= TR_NUM bl {
                    trailIdx = 0
                }
                _getCharaPtr(pA, CH_ID_PLAYER)
                V2_set(ax, v[pA + MC_X] / UNIT_POS, v[pA + MC_Y] / UNIT_POS)
                V2_clampPointInsideRect2(ax, 0, 0, mapWidth * TILE_SIZE_PX, mapHeight * TILE_SIZE_PX)
                v[__id(trailHead) + trailIdx] = ((ay & 0xffff) << 16) | (ax & 0xffff)
            }
            //----------------------------
            //マップタイル
            @loop MAP_SHOW_NUM_Y .dst(ay) bl {
                @loop MAP_SHOW_NUM_X .dst(ax) bl {
                    V2_set(bx,
                        ax + scrX / TILE_SIZE_PX,
                        ay + scrY / TILE_SIZE_PX
                    )
                    V2_set(cx,
                        ax * TILE_SIZE_PX - scrX % TILE_SIZE_PX,
                        ay * TILE_SIZE_PX - scrY % TILE_SIZE_PX
                    )
                    _getPixelFromMap(col, bx, by)
                    _getMapTilePattern(cell, col)
                    pid = PIC_TILE + ay * MAP_SHOW_NUM_X + ax
                    @pic.show[pid] .pos(cx, cy) .cell(cell) mapTilePicCmd
                }
            }
            //----------------------------
            //背景
            //一枚
            @if `sceneBit & SC_BIT_SCR_SINGLE bl {
                pid = PIC_BACK + 3
                cell = stageNumber + 1
                @pic.show[pid] .pos(0,0) .cell(cell) bgPicCmd

                @loop 3 .dst(iA) bl {
                    pid = PIC_BACK + iA
                    @pic.move[pid] .pos(0,0) .trans(100)
                }

            //スクロール
            } .else bl {
                @loop 4 .dst(iA) bl {
                    V2_set(ax,
                        iA % 2 * WINDOW_WIDTH  - ((scrX / 2) % WINDOW_WIDTH),
                        iA / 2 * WINDOW_HEIGHT - ((scrY / 2) % WINDOW_HEIGHT)
                    )
                    pid = PIC_BACK + iA
                    cell = stageNumber + 1
                    @pic.show[pid] .pos(ax,ay) .cell(cell) bgPicCmd
                }
            }
            //----------------------------
            //振動
            @if `sceneBit & SC_BIT_SHAKE bl {
                @if shakeTimer <= 0 bl {
                    @scr.shake .once(20) .value(1, 9)
                    shakeTimer = rnd(40, 80) * 60 / 10
                } .else bl {
                    shakeTimer -= 1
                }
            }
        }
    }

    @label.set "gameEnd"
    bl {
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, TS_MINIGAME, NUM_OF_STR)
        restoreBGM()
        fastFadeInTintOnly(1)
        //揺れも初期化しておく
        @scr.shake .once(0) .value(0, 9)
    }
}