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


cev[CEV_LICH_WAY] .name("mg_リッチーみっちー") {

    def {
        NUM_OF_VAR = 128
        NUM_OF_STR = 8
        NUM_OF_PIC = 24

        BASE_LAYER = 6
        FRAME_LAYER = 7

        PATH_FRAME       = "lw/fr"
        PATH_BG          = "lw/bg"
        PATH_ICON        = "lw/ic"
        PATH_CHARA       = "lw/ch"
        PATH_MESSAGE_BOX = "lw/me"

        PIC_HEAD   = 1
        PIC_FRAME  = 2
        PIC_SCENE  = 3//+0_+1
        PIC_CHARA  = 5
        PIC_SELECT = 6//+0_+3
        PIC_CURSOR = 10
        PIC_PRICE_TEXT= 11
        PIC_DESC_TEXT = 12
        PIC_LOG_TEXT  = 13
        PIC_PL_TEXT   = 14
        PIC_EN_TEXT   = 15
        PIC_FI_TEXT   = 16
        PIC_PL_DAMAGE = 17
        PIC_EN_DAMAGE = 18
        PIC_MES_BOX   = 19
        PIC_MES_TEXT  = 20
        PIC_MES_FACE  = 21

        //選択
        SELECT_NUM = 4
        SELECT_FIELD = 0
        SELECT_SORT
        SELECT_BATTLE
        SELECT_CONTROL
        SELECT_BUY
        SELECT_PUT_SKILL
        SELECT_CORPSE

        //イベントの状態
        EV_STATE_NONE = 0
        EV_STATE_WAIT
        EV_STATE_MESSAGE
        EV_STATE_SELECT
        EV_STATE_COMMAND

        //フラグ
        EV_FLAG_CURSOR     = 1 << 0
        EV_FLAG_SELECT     = 1 << 1
        EV_FLAG_DESC       = 1 << 2
        EV_FLAG_FIELD      = 1 << 3
        EV_FLAG_PL_STATUS  = 1 << 4
        EV_FLAG_EN_STATUS  = 1 << 5
        EV_FLAG_LOG        = 1 << 6
        EV_FLAG_SE_CURSOR  = 1 << 7
        EV_FLAG_SE_DECISION= 1 << 8
        EV_FLAG_SE_CANCEL  = 1 << 9

        //戦闘中のフラグ
        BT_FLAG_BOSS      = 1 << 0
        BT_FLAG_SPECIAL   = 1 << 1
        BT_FLAG_DEF       = 1 << 2
        BT_FLAG_EN_CHARGE = 1 << 3
        BT_FLAG_EN_STUN   = 1 << 4
        BT_FLAG_STUN_1    = 1 << 5
        BT_FLAG_STUN_2    = 1 << 6
        BT_FLAG_STUN_3    = 1 << 7

        //イベント
        EV_TYPE_NONE = 0
        EV_TYPE_CONTROL
        EV_TYPE_BUY
        EV_TYPE_CORPSE
        EV_TYPE_BATTLE
        EV_TYPE_BOSS

        //行動
        ACT_NONE
        ACT_ATTACK
        ACT_STUN
        ACT_CURSE
        ACT_RECOVER
        ACT_CHARGE

        //セル
        CELL_CURSOR   = 1
        CELL_NONE     = 2
        CELL_FORWARD  = 3
        CELL_REPLACE  = 4
        CELL_BACK     = 5
        CELL_HP_TO_EP = 7
        CELL_EP_TO_HP = 8
        CELL_GET_HP   = 9
        CELL_GET_EP   = 10
        CELL_OPEN     = 11
        CELL_ESCAPE   = 12
        CELL_NO_ESC   = 13
        CELL_SKILL    = 16
        CELL_FACE     = 33
        CELL_FIELD_BG = 9
        CELL_ENEMY    = 4

        //スキル
        SK_NONE = 0
        SK_RAGE
        SK_HOPE
        SK_DEVIL
        SK_CIRCLE
        SK_SOUL
        SK_RIPPER
        SK_SAINT
        SK_JEWEL
        SK_BELL//没
        SK_AWAIT

        //フィールド
        FI_INTERVAL = 60
        FI_CREATE = 10//15
        FI_NAME_X = 94
        FI_NAME_Y = 18
        FI_STEP_X = 224
        FI_STEP_Y = 34

        //敵
        BOSS_NUM = 3
        EN_NONE = 0
        EN_GOBLIN
        EN_BANSHEE
        EN_ARTIST
        EN_GROTE
        EN_PLANT
        EN_TROOPER
        EN_ROBOT
        EN_WIND
        EN_CUPID
        EN_MERC
        EN_WIZARD
        EN_ANGEL

        //カーソル
        CURSOR_X = 240
        CURSOR_Y = 32
        CURSOR_SIZE = 32
        CURSOR_REPEAT = 8

        //ログ
        LOG_COUNT = 6
        LOG_X = 4
        LOG_Y = 48

        //表示
        REF_X = 96
        REF_Y = 48
        MES_BOX_X  = 80
        MES_BOX_Y  = 148
        MES_STR_X  = 116
        MES_STR_Y  = 152
        MES_FACE_X = 82
        MES_FACE_Y = 150
        PRICE_TEXT_X = 242
        PRICE_TEXT_Y = 176
        DESC_X = 4
        DESC_Y = 224
        EN_STATUS_X = 181
        EN_STATUS_Y = 164
        PL_STATUS_X = 98
        PL_STATUS_Y = 164

        //ステータス
        INC_MAX_HP = 2
        INC_MAX_EXP = 3
        INC_EXP = 20
        ESC_RATE = 70
    }

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

        upperPicCmd = bl {
            .chromakey(1)
            .mapLayer(FRAME_LAYER)
            .eraseWhenTransfer
            .affectedByTint
            .affectedByFlash
            .affectedByShake
        }

        bgPicCmd = {
            PATH_BG
            .topLeft
            .pos(REF_X, REF_Y)
            .grid(4, 4)
            basePicCmd
        }

        charaPicCmd = {
            PATH_CHARA
            .topLeft
            .grid(4, 4)
            basePicCmd
        }

        iconPicCmd = {
            PATH_ICON
            .topLeft
            .grid(8, 5)
            upperPicCmd
        }

        //通常文字列
        normalTextPixCmd = bl {
            .size(0, 0)
            .font("", 10)
            .spacing(0, 4)
            .skin "" .nobg .noframe .noPadding .noGradation .noShadow
            upperPicCmd
        }

        //ステータス表示文字列
        statusTextPixCmd = bl {
            .size(0, 0)
            .font("", 12)
            .spacing(0, 4)
            .skin "" .nobg .noframe .noPadding .noGradation .noShadow
            upperPicCmd
        }

    }

    defv {
        varHead = TV_MINIGAME

        pid
        cell
        state
        alpha
        beta
        type
        power
        act
        ax
        ay

        iptY
        iptD
        iptC
        iptS

        overallTurn
        overallEnemy

        stageLevel
        windLevel
        priceHp

        waitParam
        waitTimer

        eventState
        eventFlag
        battleTurn
        battleFlag
        cursorPos
        selectParam
        selectLayer
        preBackground
        logCount
        fieldStep
        fieldIdx
        nextEvent

        enType
        enHp
        enLevel

        plHp
        plMaxHp
        plExp
        plMaxExp
        plLevel

        plSkill_1
        plSkill_2
        plSkill_3

        selectCell_1
        selectCell_2
        selectCell_3
        selectCell_4

        selectMode_1
        selectMode_2
        selectMode_3

        buyItem_1
        buyItem_2

        fieldHead
        varFoot = __id(fieldHead) + FI_CREATE
    }

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

    deft {
        strMessage = TS_MINIGAME
        strEvents
        strLog
        strLine
        strParam1
        strParam2
        strParam3
    }

    //敵のステータスを初期化する
    __fn _initEnemyStatus bl {
        v[__id(enType)..__id(enLevel)] = 0
    }


    //イベントの状態を変える
    __fn _changeEventState $state bl {
        eventState = $state
    }

    //イベントコマンドを追加する
    __fn _pushEvents $flash $events bl {
        __if $flash == TRUE bl {
            strEvents .asg($events .extract)
        } .else bl {
            strEvents .asg(__str($events, NEWLINE, "\", strEvents) .extract)
        }
    }

    //入力状態を更新する
    __fn _updateKey $dvInput $key bl {
        @key.input .dst(alpha) $key
        v[__id($dvInput)] = (alpha) ? (v[__id($dvInput)] + 1) : (0)
    }

    //選択レイヤーを追加する
    __fn _pushSelectLayer $mode bl {
        selectLayer += 1
        v[__id(selectMode_1) + selectLayer] = $mode
    }

    //選択レイヤーを取り除く
    __fn _popSelectLayer bl {
        selectLayer -= 1
    }

    //選択レイヤーを初期化する
    __fn _initSelectLayer $mode bl {
        selectLayer = 0
        selectMode_1 = $mode
    }

    //現在のレイヤーを変更する
    __fn _changeSelectLayer $mode bl {
        v[__id(selectMode_1) + selectLayer] = $mode
    }

    //プレイヤーのダメージ表示
    __fn _showPlayerDamage $str bl {
        @pic.strpic [PIC_PL_DAMAGE] $str .pos(PL_STATUS_X + 20, PL_STATUS_Y - 8) .topLeft .trans(-500) statusTextPixCmd
        @pic.move [PIC_PL_DAMAGE] .relative .pos(0, -8) .scale(0) .trans(600) .time(10)
    }

    //敵のダメージ表示
    __fn _showEnemyDamage $str bl {
        @pic.strpic [PIC_EN_DAMAGE] $str .pos(EN_STATUS_X + 20, EN_STATUS_Y - 8) .topLeft .trans(-500) statusTextPixCmd
        @pic.move [PIC_EN_DAMAGE] .relative .pos(0, -8) .scale(0) .trans(600) .time(10)
    }

    //ログに文字列を入力する
    __fn _pushLog $str bl {
        logCount += 1
        strLog .cat(__str($str, NEWLINE) .extract)
        bitOn(eventFlag, EV_FLAG_LOG)
    }

    //ログを初期化する
    __fn _initLog bl {
        logCount = 0
        strLog .asg("")
        bitOn(eventFlag, EV_FLAG_LOG)
    }

    //イベントの分布
/*
    def FIELD_PATTREN_1 = 
    [   EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE,
        0, 0, 0, 0, 0,
        EV_TYPE_BUY, EV_TYPE_CONTROL, EV_TYPE_CORPSE, EV_TYPE_CORPSE, EV_TYPE_CORPSE]

    def FIELD_PATTREN_2 = 
    [   EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE,
        EV_TYPE_BATTLE, 0, 0 ,0, 0,
        EV_TYPE_BUY, EV_TYPE_BUY, EV_TYPE_CONTROL, EV_TYPE_CORPSE, EV_TYPE_CORPSE ]

    def FIELD_PATTREN_3 =
    [   EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE,
        EV_TYPE_BATTLE, 0, 0, 0, 0,
        EV_TYPE_BUY, EV_TYPE_BUY, 0, EV_TYPE_CONTROL, EV_TYPE_CONTROL ]
*/
    def FIELD_PATTREN_1 = 
    [   EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, 0, 0,
        EV_TYPE_BUY, EV_TYPE_CONTROL, EV_TYPE_CORPSE, 0, 0]

    def FIELD_PATTREN_2 = 
    [   EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, 0,
        EV_TYPE_BUY, EV_TYPE_CONTROL, EV_TYPE_CORPSE, EV_TYPE_CORPSE, 0 ]

    def FIELD_PATTREN_3 =
    [   EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE, EV_TYPE_BATTLE,
        EV_TYPE_BUY, EV_TYPE_BUY, EV_TYPE_CONTROL, 0, 0 ]


    //敵のパターン(type)
    def GET_EN_PATTERN_1 = [EN_GOBLIN, EN_BANSHEE, EN_ARTIST][type]
    def GET_EN_PATTERN_2 = [EN_PLANT, EN_ROBOT, EN_TROOPER][type]
    def GET_EN_PATTERN_3 = [EN_CUPID, EN_MERC, EN_WIZARD][type]
    //商品のパターン
    //1
    def SET_GOODS_1 = bl {
        buyItem_1 = [SK_RAGE, SK_HOPE][rnd(0, 1)]
        buyItem_2 = [SK_DEVIL, SK_JEWEL, SK_SAINT, SK_SAINT][rnd(0, 3)]
    }
    //2
    def SET_GOODS_2 = bl {
        buyItem_1 = [SK_SOUL, SK_CIRCLE, SK_DEVIL][rnd(0,2)]
        buyItem_2 = [SK_RIPPER, SK_SAINT, SK_SAINT][rnd(0,2)]
    }
    //3
    def SET_GOODS_3 = bl {
        buyItem_1 = [SK_RAGE, SK_HOPE, SK_DEVIL, SK_CIRCLE][rnd(0, 3)]
        buyItem_2 = [SK_SOUL, SK_RIPPER, SK_JEWEL, SK_SAINT][rnd(0, 3)]
    }
    //商品の値段
    def GET_PRICE_HP = [10, 15, 20][stageLevel]
    //フィールドの名前
    def FIELD_NAMES = ["くちはてた こうざん", "れいき ただよう いせき", "きり ふかき きょとう"]
    //セル番号に対応した説明文
    def DESC_TEXTS = ["",//0
"",//カーソル
"",//なし
"まえに すすみます",
"スキルを ならびかえます",
"もどります",
"HPを 4 さげて 1ぽ さきをみる(ぼつ)",
"さいだいHPを 5 さげて LVを 1 ふやす",
"LVを 1 さげて さいだいHPを 1 と HPを 4 ふやす",
"HPが ふえる",
"けいけんちを 20 もらう",
"なにが でるかな",
"にげる でも さいしょのターンだけ せいこうりつ 70%",
"ここで にげたら リッチが すたるぜ",
"",
"",
"",
"もうじゃの いかり: こうげきする いりょくは レベルと おなじ",
"らいせへの きぼう: こうげき しつつ まもるが しびれに よわい",
"あくま びーむ: 10 こてい ダメージと レベルを 1 さげる",
"しびれ さーくる: しびれさせる かくりつは 30%",
"こんじょう だま: HPによって いりょくが 0～200% かわる",
"ひきさき ま: HPを 20 つかった 2.5ばい こうげき",
"せいじん ぼう: かいふく する",
"のろわれた ほうせき: なげると いたい",
"よびりん: つかうと しょうにんか ネクロが でる かくりつ +15%(ぼつ)",
"しびれた！ このターンは なにもしない"
]
    //開始イベント
    def OPENING_EVENT = 
"bgm,0
weather,0
background,2
message,1,3
わがなは りっちー
やることやって
ふろうふしに なりました
message,1,3
たかい とうを のぼると
ねがいを かなえて
もらえるって！
message,1,3
じゃあさ ふろうふしに
なる ほうほうを
おしえてほしいな！
close_message
background,5
bgm,1
create_field
reserve_event"
    //ゲームオーバー
    def LOSE_EVENT =
"bgm,0
chara,0
background,3
wait,60
retry"
    //ボス1に遭遇した時のイベント
    def BATTLE_EVENT_1 =
"message,4,2
とつぜんですが
ボスせんの じかんです
message,4,1
みにくく しねー！
close_message"
    //ボス1に勝利した時のイベント
    def WIN_EVENT_1 =
"bgm,0
background,4
wait,30
hide_ui
message,4,3
ぼくは しなないぞ
みにくい からだと
ひきかえにな
message,1,1
うん
message,4,3
すごい がんばって
ふしに なった
すごい だろ
message,1,1
くろうは わかる
message,4,3
ふしに なったけど
どうすれば いいんだ
シクシク
message,1,1
あんた めが きれいだね
message,4,1
え？（とぅんく）
message,1,3
おめかし すればいいよ
おれも ミイラだけど
でっかく みせてます
message,4,3
でも みにくいやつが
おめかし しても
みにくいまま
message,1,3
そういうことばっか 
いってると みにくく
ふけるぞ
message,1,2
ていうか まずは
ふくを きなさい
message,4,2
うーん わかったよ
おしゃれ してみるね
message,4,2
おれいに いいこと
おしえてあげる
message,4,3
せんとうちゅうにね
Shiftか みぎを おすと
スキルを くだけるの
message,4,3
スキルが きえるけど
いりょくは 2ばい！
ためしてみてね
message,1,2
ありがとう
じゃ さようなら
message,4,1
さようなら
close_message
background,5
bgm,2
weather,2
create_field
reserve_event"
    //ボス2に勝利した時のイベント
    def BATTLE_EVENT_2 =
"message,5,2
てめー おい こら
なんど EXPを すった？
message,5,3
その かずだけ
わたしの うらみは
ましまし
message,5,1
きさまも しねー！
close_message"
    //ボス2に勝利した時のイベント
    def WIN_EVENT_2 =
"bgm,0
background,4
wait,30
hide_ui
message,5,3
どいつ こいつも
わたしを なんだと
おもっているのか
message,1,2
きゅうに なんなん
おこってるのかい？
message,5,3
おまえ みたいなのは
したいを もてあそぶ
ひどい！
message,1,2
あー
かえす ことばも ない
message,1,1
つちに かえりたいの？
message,5,3
わたしは かぜになる
だれの ものにも ならない
どこにでも いきたい
message,1,1
ろまんちっく！
message,1,3
でも そういうのは
いきてる うちに
やったほうが いいよ
message,5,3
わたしは しんどらん
この ミイラやろう め
なめとんのか
message,1,3
うん なんていうかさ
みもふたも ないこと
いうけど
message,1,3
ゾンビに なれば
からだが よわいの
なおるよ
message,5,1
ほんと？
message,1,2
でも おていれが たいへん
すぐに くさくなる
message,5,1
やだー！
message,1,3
とにかく ながいき
したいなら てつだうよ
だから ゆるして
message,5,1
たよりたくねぇ
message,5,2
しかし わたしの まけ
ここは ひいてやる
message,5,2
ひとつ おぼえとけ
このさきに したいは ない
message,1,1
やだー！
message,5,2
ふはは さらばだ
かぜの なかの すーばるー
message,1,1
すなの なかの ぎんがー！
close_message
background,5
bgm,3
weather,0
create_field
reserve_event"
    //ボス3に遭遇した時のイベント
    def BATTLE_EVENT_3 =
"bgm,0
chara,16
wait,30
message,6,2
きんきに みをやつした
おろかな ひとのこよ…
message,1,3
ごたくは いいよ
ねがいが かなうのは
まじ？
message,6,2
あるいみでは まじ です
ふろうふし になりたい？
message,1,1
いえーす
message,6,3
あなたは すでに
ふし じゃないですか
やだー！
message,1,2
おれは おれのやりかたで
ふしに なったの
message,1,3
かみとか てんしとかが
ちょちょいと
できるのならさ
message,1,2
どうやって やるのか
しりたいじゃん
message,6,2
よくぶかい ミイラですね
こうきしんの けだもの！
message,1,2
そういう にんげんも
いますね
message,6,2
では さばきという
なの しれんを うけなさい
message,1,2
けっきょく こうなる
おてやわらかに おねがい
message,6,2
いえ
じょうかして けします
message,1,1
まじ？
close_message
bgm,4"
    //ボス3に勝利した時のイベント -> エンディング
    def WIN_EVENT_3 =
"update_highscore
bgm,5
background,6
wait,30
hide_ui
message,6,2
はい さんかしょうの
てんしのはね です
message,1,1
は？
message,6,1
は じゃないが
message,6,3
ここは ゆうしゃを
そだてる かくし
だんじょん
message,6,1
でんせつを しらないの？
message,1,1
でんせつって？
message,6,2
ああ！
さっき いいました
message,6,3
その そうびは
ぼうぎょりょくが
とても たかい
message,6,3
ふじみの ように
じょうぶに なれます
よかったね
message,1,3
ほねおりぞん
くたびれもうけの
しゃれこうべ
message,6,3
まぁまぁ
ここは とても たかくて
てんごくに ちかい
message,6,2
すこし てんごくを
のぞいても いいですよ
message,1,3
いやぁ
そういうのは いいっす
かえりますん
message,6,1
さいですか
message,6,3
ちしきも いいけど
ながいきするなら
おもいでを だいじにね
message,1,1
はーい
message,2,1
おめでとう りっちー
message,3,2
すごい たたかい でした
りっちー さん
message,1,1
なんで いるの
message,3,2
もちろん
しょうばい ですよ
message,3,2
でも いまは あなたの
しょうりを いわいます
message,2,3
てんしの したいを
ひろえると おもって
ついてきました！
message,6,1
ぶちころすぞ
message,2,1
ごめす
message,1,1
なんだかなぁ
background,7
message,7,2
このあと めっちゃ
いわってもらったとさ
message,7,1
めでてぇな！
message,0,2
 リッチーみっちー
      おわり
close_message
show_result
retry"

    //------------------------------------------------------------------------------------
    //開始処理
    bl {
        //変数を初期化
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, TS_MINIGAME, NUM_OF_STR)
        //BGMを記憶する
        storeAndStopBGM()
        //メッセージの表示位置
        msgBottom()
        //ピクチャ
        @pic.show[PIC_FRAME] PATH_FRAME .topLeft .pos(0, 0) upperPicCmd

        @label.jump "gameLoop"
    }

    //------------------------------------------------------------------------------------
    //ゲーム処理
    @label.set "gameLoop"
    bl {
        //暗転
        fastFadeInTintOnly(1)
        //変数を一括で初期化する
        assignVarUsingDeclared(varHead, varFoot, 0)
        assignStrUsingDeclared(strMessage, strParam2, "")
        //ピクチャを初期化する
        hidePicturesForEach( [PIC_CHARA, PIC_CURSOR, PIC_DESC_TEXT] )
        //初期背景
        preBackground = 1
        //初期イベント
        _initSelectLayer(SELECT_FIELD)
        _changeEventState(EV_STATE_COMMAND)
        //開始イベント
        _pushEvents(FALSE, OPENING_EVENT)
        //画面更新フラグ
        bitOn(eventFlag, EV_FLAG_FIELD | EV_FLAG_PL_STATUS | EV_FLAG_EN_STATUS | EV_FLAG_SELECT | EV_FLAG_LOG)
        //イベント用ステータス
        windLevel = 0
        stageLevel = 0
        //初期ステータス
        plMaxHp = 20
        plHp = plMaxHp
        plLevel = 4
        plExp = 0
        plMaxExp = plLevel * INC_MAX_EXP
        plSkill_1 = SK_RAGE
        plSkill_2 = SK_HOPE
        //テストプレイ用
        //plMaxHp = 126
        //plHp = 66
        //plLevel = 20
        //plExp = 0
        //plMaxExp = plLevel * INC_MAX_EXP
        //plSkill_1 = SK_CIRCLE
        //plSkill_2 = SK_SOUL
        //plSkill_3 = SK_RIPPER
        //stageLevel = 2
        //fieldStep = stageLevel * FI_INTERVAL
        
        //----------------------------
        //ループ
        @loop bl {
            @wait(0)
            //----------------------------
            //入力
            //カーソル
            @key.input .dst(alpha) bl {
                .up
                .down
            }
            alpha = (alpha == KEY_UP ? -1 : 0) + (alpha == KEY_DOWN ? 1 : 0)
            iptY = (iptY && alpha * iptY <= 0) ? (0) : (iptY + alpha)

            //決定
            _updateKey(iptD, bl {.left .decision} )
            _updateKey(iptC, bl {.cancel} )
            _updateKey(iptS, bl {.right .shift} )

            //----------------------------
            pseudoSwitchState(eventState,
            //----------------------------
            //指定フレーム待機する(param:待機時間)
            [EV_STATE_WAIT, bl {
                @if waitTimer >= waitParam bl {
                    _changeEventState(EV_STATE_COMMAND)
                } .else bl {
                    waitTimer += 1
                }
            },
            //----------------------------
            //メッセージの入力待ち
            EV_STATE_MESSAGE, bl {
                //キャンセル or 特殊を押しっぱなし or 決定を押す
                @if `(iptC > 0 && iptC % 4 == 0) || (iptS > 0 && iptS % 4 == 0) || iptD == 1 bl {
                    _changeEventState(EV_STATE_COMMAND)
                }
            },
            //----------------------------
            //選択
            EV_STATE_SELECT, bl {
                state = v[__id(selectMode_1) + selectLayer]
                //----------------------------
                //カーソル移動
                @if `abs(iptY) % CURSOR_REPEAT == 1 bl {
                    cursorPos = (cursorPos + (iptY > 0 ? 1 : -1) + SELECT_NUM) % SELECT_NUM
                    bitOn(eventFlag, EV_FLAG_CURSOR | EV_FLAG_DESC | EV_FLAG_SE_CURSOR)
                //----------------------------
                //決定
                } .elif `iptD == 1 bl {
                    //共通
                    //戦闘中を除く
                    @if `selectLayer <= 0 && state != SELECT_BATTLE bl {
                        //前進
                        @if cursorPos == 0 bl {
                            _pushEvents(FALSE, "next_step")
                            _changeEventState(EV_STATE_COMMAND)

                        //並び替え画面へ
                        } .elif cursorPos == 1 bl {
                            selectParam = -1

                            _pushSelectLayer(SELECT_SORT)
                            _changeEventState(EV_STATE_SELECT)
                            bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_DESC | EV_FLAG_SE_DECISION)
                        }
                    }
                    //----------------------------
                    //並べ替え
                    pseudoSwitchState(state,
                    [SELECT_FIELD, bl {
                    },
                    SELECT_SORT, bl {
                        //戻る
                        @if cursorPos == 0 bl {
                            _popSelectLayer()
                            bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_CURSOR | EV_FLAG_DESC | EV_FLAG_SE_CANCEL)

                        //交換するスキルを選択する
                        } .else bl {
                            ax = cursorPos - 1
                            ay = selectParam

                            //交換
                            @if ay >= 0 bl {
                                alpha = __id(plSkill_1) + ax
                                beta  = __id(plSkill_1) + ay

                                v[alpha] .swap(v[beta], 1)
                                selectParam = -1

                                bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_SE_DECISION | EV_FLAG_DESC)

                            //選択
                            } .else bl {
                                selectParam = ax

                                //選んだアイコンを前に出す
                                pid = PIC_SELECT + cursorPos
                                @pic.move[pid] .relative .pos(-8, 0) .scale(0) .trans(0)

                                bitOn(eventFlag, EV_FLAG_SE_CURSOR)
                            }
                        }
                    },
                    //----------------------------
                    //制御
                    SELECT_CONTROL, bl {
                        //MAXHP -> LV
                        @if cursorPos == 2 bl {
                            $MAXHP = 5
                            $LV = 1

                            //最大HPが1になってもHPは変わらない
                            @if plMaxHp > $MAXHP bl {
                                plMaxHp -= $MAXHP
                                plLevel += $LV
                                plMaxExp += INC_MAX_EXP

                                _pushLog(__str("MaxHP-", $MAXHP, " & LV+", $LV))

                                bitOn(eventFlag, EV_FLAG_PL_STATUS)
                                @scr.flash .once(1) .rgbv(31, 31, 31, 16)
                                @se.play "Buff" .opt(100, 100, 50)

                            //足りない
                            } .else bl {
                                $TEXT =
"さいだいHPが たりないわ
あんた しぬわよ"
                                _changeEventState(EV_STATE_COMMAND)
                                _pushEvents(FALSE, __str("message,2,2", NEWLINE, $TEXT, NEWLINE, "close_message"))
                                bitOn(eventFlag, EV_FLAG_SE_CANCEL)
                            }
                        //LV -> MAXHP
                        } .elif cursorPos == 3 bl {
                            $MAXHP = 1
                            $HP = 4
                            $LV = 1

                            //HPが最大HP未満の場合はHPも増える
                            @if plLevel > 1 bl {
                                plMaxHp += $MAXHP
                                plLevel -= $LV
                                plMaxExp -= INC_MAX_EXP

                                @if plHp < plMaxHp bl {
                                    plHp = min(plHp + $HP, plMaxHp)
                                    _pushLog(__str("MaxHP+", $MAXHP, " HP+", $HP, " LV-", $LV))
                                } .else bl {
                                    _pushLog(__str("MaxHP+", $MAXHP, " LV-", $LV))

                                }

                                bitOn(eventFlag, EV_FLAG_PL_STATUS)
                                @scr.flash .once(1) .rgbv(31, 31, 31, 16)
                                @se.play "Buff" .opt(100, 80, 50)
                            //足りない
                            } .else bl {
                                $TEXT =
"これいじょう LVを
さげられないようね"
                                _changeEventState(EV_STATE_COMMAND)
                                _pushEvents(FALSE, __str("message,2,2", NEWLINE, $TEXT, NEWLINE, "close_message"))
                                bitOn(eventFlag, EV_FLAG_SE_CANCEL)
                            }
                        }
                    },
                    //----------------------------
                    //買う
                    SELECT_BUY, bl {
                        @if `between(cursorPos, 2, 3) bl {
                            //変数位置
                            selectParam = __id(buyItem_1) + cursorPos - 2
                            //スキル
                            @if `v[selectParam] > SK_NONE bl {
                                //値段チェック
                                @if `plHp <= priceHp bl {
                                    //足りなくても変えるように
                                    $TEXT =
"HPが たりてないよ
でも まぁいいか
ツケに しましょう"
                                    _changeEventState(EV_STATE_COMMAND)
                                    _pushEvents(FALSE, __str("message,3,3", NEWLINE, $TEXT, NEWLINE, "close_message"))

                                    //決定音のみ
                                    //選択肢の更新はイベント終了後に行う
                                    bitOn(eventFlag, EV_FLAG_SE_DECISION)

                                //決定音 + 選択肢を更新する
                                } .else bl {
                                    bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_CURSOR | EV_FLAG_SE_DECISION)
                                }
                                //置き場所を選ぶ
                                _pushSelectLayer(SELECT_PUT_SKILL)
                            }
                        }
                    },
                    //----------------------------
                    //スキルを設置する
                    SELECT_PUT_SKILL, bl {
                        //戻る
                        @if cursorPos == 0 bl {
                            _popSelectLayer()
                            bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_CURSOR | EV_FLAG_DESC | EV_FLAG_SE_CANCEL)

                        } .elif `between(cursorPos, 1, 3) bl {
                            //スキル変数の位置
                            alpha = __id(plSkill_1) + cursorPos - 1
                            //購入物の位置
                            beta = selectParam
                            //設置
                            v[alpha] = v[beta]
                            //戻る
                            _popSelectLayer()
                            bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_CURSOR | EV_FLAG_SE_DECISION)
                            //戻った先が店状態だった場合、支払う
                            alpha = v[__id(selectMode_1) + selectLayer]
                            @if alpha == SELECT_BUY bl {
                                plHp = max(plHp - priceHp, 1)

                                //購入したものは消える
                                v[beta] = SK_NONE

                                bitOn(eventFlag, EV_FLAG_PL_STATUS)

                                _pushLog(__str("はらった Hp-\", priceHp))

                                @se.play "register" .opt 100, 100, 50

                            //戻った先が死体だった場合、片付ける
                            } .elif alpha == SELECT_CORPSE bl {
                                _changeSelectLayer(SELECT_FIELD)

                                //購入したものは消える
                                v[beta] = SK_NONE

                                _pushLog("スキルを うばった")

                                //キャラ絵を消す
                                @se.play "Recovery3" .opt(100, 100, 50)
                                @pic.move[PIC_CHARA] .relative .pos(0,0) .scale(0) .trans(0) .rgbs(200, 200, 200, 0)
                                @wait(0)
                                @pic.move[PIC_CHARA] .relative .pos(0,0) .scale(0) .trans(100) .rgbs(100, 100, 100, 0) .time(1)
                            }
                        }
                    },
                    //----------------------------
                    //死体
                    SELECT_CORPSE, bl {
                        //スキルを拾う
                        @if cursorPos == 2 bl {
                            //変数位置
                            selectParam = __id(buyItem_1) + cursorPos - 2
                            @if `v[selectParam] > SK_NONE bl {
                                //置き場所を選ぶ
                                _pushSelectLayer(SELECT_PUT_SKILL)
                                bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_CURSOR | EV_FLAG_SE_DECISION)
                            }

                        //LV+
                        } .elif cursorPos == 3 bl {
                            alpha = INC_EXP

                            plExp += alpha
                            windLevel += 1

                            $TEXT =
"ごぞうろっぷに しみる
おれは ミイラ だけど"
                            _pushLog(__str("Exp +\", alpha))
                            _changeSelectLayer(SELECT_FIELD)
                            _changeEventState(EV_STATE_COMMAND)
                            _pushEvents(FALSE, __str("message,1,2", NEWLINE, $TEXT, NEWLINE, "close_message", NEWLINE, "check_levelup"))
                            bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_PL_STATUS)

                            //キャラ絵を消す
                            @se.play "Recovery3" .opt(100, 100, 50)
                            @pic.move[PIC_CHARA] .relative .pos(0,0) .scale(0) .trans(0) .rgbs(200, 200, 200, 0)
                            @wait(0)
                            @pic.move[PIC_CHARA] .relative .pos(0,0) .scale(0) .trans(100) .rgbs(100, 100, 100, 0) .time(1)
                        }
                    },
                    //----------------------------
                    //戦闘
                    SELECT_BATTLE, bl {
                        //逃げる
                        @if cursorPos == 0 bl {
                            //ボスからは逃げられない
                            @if `!(battleFlag & BT_FLAG_BOSS) bl {
                                //2ターン目以降は確実に成功する
                                @if `battleTurn > 0 || rnd(0, 99) < ESC_RATE bl {
                                    _pushEvents(FALSE, "battle_escape")
                                    _changeEventState(EV_STATE_COMMAND)

                                //失敗
                                } .else bl {
                                    _pushLog("にげられない！")

                                    alpha = SK_AWAIT
                                    _pushEvents(FALSE, __str("battle_start_turn,\", alpha, ",0"))
                                    _changeEventState(EV_STATE_COMMAND)
                                }
                            }
                        //技
                        } .elif `between(cursorPos, 1, 3) bl {
                            //スキル
                            alpha = v[__id(plSkill_1) + cursorPos - 1]
                            //痺れている場合は別のスキルに変わる
                            @if `battleFlag & (BT_FLAG_STUN_1 << (cursorPos - 1)) {
                                alpha = SK_AWAIT

                            //スキルが無い上に逃げられない場合、特別に選べる
                            } .elif `plSkill_1 == SK_NONE &&
                                     plSkill_2 == SK_NONE &&
                                     plSkill_3 == SK_NONE &&
                                     (battleFlag & BT_FLAG_BOSS) bl {
                                alpha = SK_AWAIT
                            }

                            //プレイヤーの後、敵が行動する
                            @if alpha > SK_NONE bl {
                                _pushEvents(FALSE, __str("battle_start_turn,\", alpha, ",0"))
                                _changeEventState(EV_STATE_COMMAND)
                            }
                        }
                    } ],
                    bl {}
                    )
                //----------------------------
                //キャンセル
                } .elif `iptC == 1 bl {
                    //共通
                    @if selectLayer <= 0 bl {
                        //ポーズ
                        _changeEventState(EV_STATE_COMMAND)
                        _pushEvents(FALSE, "pause")
                        bitOn(eventFlag, EV_FLAG_SE_CANCEL)
                    
                    } .elif selectLayer > 0 bl {
                        _popSelectLayer()
                        bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_CURSOR | EV_FLAG_DESC | EV_FLAG_SE_CANCEL)
                    }
                //----------------------------
                //特殊
                } .elif `iptS == 1 bl {
                    //スキルを砕く
                    @if state == SELECT_BATTLE bl {
                        @if `between(cursorPos, 1, 3) bl {
                            //スキル
                            beta = __id(plSkill_1) + cursorPos - 1
                            alpha = v[beta]

                            //痺れている場合は砕けない
                            @if `battleFlag & (BT_FLAG_STUN_1 << (cursorPos - 1)) {
                                bitOn(eventFlag, EV_FLAG_SE_CANCEL)

                            } .elif alpha > SK_NONE bl {
                                //効果音
                                @se.play "Ice10" .opt(100, 100, 50)
                                //選んだアイコンを前に出す
                                pid = PIC_SELECT + cursorPos
                                @pic.move[pid] .relative .pos(-8, 0) .scale(0) .trans(0) .time(1) .rgbs(200, 200, 200, 100)
                                @wait(5)
                                @pic.move[pid] .relative .pos(0, 0) .scale(50) .trans(100) .time(2) .rgbs(200, 200, 200, 100)
                                @wait(0)

                                //スキルを消す
                                v[beta] = SK_NONE

                                //プレイヤーの後、敵が行動する
                                _pushEvents(FALSE, __str("battle_start_turn,\", alpha, ",1"))
                                _changeEventState(EV_STATE_COMMAND)
                            }
                        }
                    }
                }
            },
            //----------------------------
            //コマンド
            EV_STATE_COMMAND, bl {
                //イベントコマンドの数
                strEvents .getLen(alpha)

                //イベントコマンド無し
                //選択状態に移る
                @if alpha <= 0 bl {
                    _changeEventState(EV_STATE_SELECT)
                    bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_CURSOR)

                } .else bl {
                    //一行読み込み
                    strEvents .popLine(strLine)
                    //,で区切る
                    strLine .split(",", strParam1, alpha)
                    
                    //コマンドごとに分岐する
                    @if strParam1.eq "message" bl {
                        //顔グラ(0:空白)
                        strParam2 .toNum(alpha)
                        cell = (alpha <= 0) ? (0) : (alpha - 1 + CELL_FACE)

                        strMessage .asg("")
                        strParam3 .toNum(alpha)
                        @loop alpha bl {
                            strEvents .popLine(strLine)
                            strMessage .cat(__str("\", strLine, NEWLINE) .extract)
                        }

                        @pic.show [PIC_MES_FACE] .pos(MES_FACE_X, MES_FACE_Y+4) .topLeft .cell(cell) iconPicCmd
                        @pic.move [PIC_MES_FACE] .relative .pos(0, -4) .scale(0) .trans(0) .time(1)

                        @pic.strpic [PIC_MES_TEXT] strMessage .pos(MES_STR_X, MES_STR_Y+4) .topLeft normalTextPixCmd
                        @pic.move   [PIC_MES_TEXT] .relative .pos(0, -4) .scale(0) .trans(0) .time(1)

                        @pic.show [PIC_MES_BOX] PATH_MESSAGE_BOX .pos(MES_BOX_X, MES_BOX_Y+4) .topLeft upperPicCmd
                        @pic.move [PIC_MES_BOX] .relative .pos(0, -4) .scale(0) .trans(0) .time(1)

                        //入力を待つ
                        _changeEventState(EV_STATE_MESSAGE)

                    //----------------------------
                    //close_message
                    } .elif strParam1.eq "close_message" bl {
                        hidePicturesForEach( [PIC_MES_FACE, PIC_MES_TEXT, PIC_MES_BOX] )

                    //----------------------------
                    //hide_ui
                    } .elif strParam1 .eq("hide_ui") bl {
                        hidePicturesForEach( [PIC_CURSOR, PIC_DESC_TEXT, PIC_LOG_TEXT, PIC_SELECT + 0, PIC_SELECT + 1, PIC_SELECT + 2, PIC_SELECT + 3 ] )
                        _initLog()

                    //----------------------------
                    //wait
                    } .elif strParam1.eq "wait" bl {
                        strParam2 .toNum(waitParam)

                        waitTimer = 0

                        _changeEventState(EV_STATE_WAIT)

                    //----------------------------
                    //background,pattern
                    } .elif strParam1.eq "background" bl {
                        strParam2 .toNum(cell)

                        @pic.show[PIC_SCENE+0] .cell(preBackground) bgPicCmd
                        @pic.show[PIC_SCENE+1] .scale(25) .cell(cell) bgPicCmd
                        @pic.move[PIC_SCENE+1] .relative .pos(0, 0) .scale(75) .trans(0) .time(2)

                        preBackground = cell

                    //----------------------------
                    //chara,pattern
                    } .elif strParam1.eq "chara" bl {
                        strParam2 .toNum(cell)

                        //表示
                        @if cell > 0 bl {
                            @pic.show[PIC_CHARA] .pos(REF_X, REF_Y) .scale(25) .cell(cell) charaPicCmd
                            @pic.move[PIC_CHARA] .relative .pos(0, 0) .scale(75) .trans(0) .time(2)

                        //消去
                        } .else bl {
                            @pic.show[PIC_CHARA] .pos(REF_X, REF_Y) .scale(100) .cell(0) charaPicCmd
                        }

                    //----------------------------
                    //bgm,type
                    } .elif strParam1.eq "bgm" bl {
                        strParam2 .toNum(alpha)

                        @if enableDedicatedBGM.isOn bl {
                            pseudoSwitchState(alpha,
                            //停止
                            [0, bl {
                                @bgm.stop
                            },
                            //教会1
                            1, bl {
                                @bgm.play "rpgmkgb_church" .opt(0, 100, 100, 50)
                            },
                            //悪夢
                            2, bl {
                                @bgm.play "for_my_dear_nightmare" .opt(0, 100, 100, 50)
                            },
                            //教会2
                            3, bl {
                                @bgm.play "2003Cathedral" .opt(0, 100, 100, 50)
                            },
                            //ラストバトル
                            4, bl {
                                @bgm.play "legendarybattle" .opt(0, 100, 100, 50)
                            },
                            //エンディング
                            5, bl {
                                @bgm.play "2003Dreaminess" .opt(0, 100, 120, 50)
                            } ],
                            bl {}
                            )
                        }

                    //----------------------------
                    //pause
                    } .elif strParam1.eq "pause" bl {
                        @msg.choice bl {
                            .cancel(0)
                            .case "\>つづける" bl {
                                @wait(1)
                            }
                            .case "\>やめる" bl {
                                @label.jump "gameEnd"
                            }
                        }
                    //----------------------------
                    //retry
                    } .elif strParam1.eq("retry") bl {
                        replayProcess("gameLoop", "gameEnd")

                    //----------------------------
                    //weather,type(0:none 1:rain 2:snow)
                    } .elif strParam1.eq("weather") bl {
                        strParam2 .toNum(alpha)

                        @if alpha == 1 bl {
                            @scr.weather .rain .weak
                        } .elif alpha == 2 bl {
                            @scr.weather .snow .medium
                        } .else bl {
                            @scr.weather .none .medium
                        }

                    //----------------------------
                    //next_step
                    } .elif strParam1.eq "next_step" bl {
                        fieldStep += 1
                        overallTurn += 1

                        //選択状態を通常に戻す
                        _initSelectLayer(SELECT_FIELD)

                        //歩数表示
                        bitOn(eventFlag, EV_FLAG_FIELD)

                        //ボス戦用の背景
                        @if nextEvent == EV_TYPE_BOSS bl {
                            alpha = 1
                        //通常
                        } .else bl {
                            alpha = fieldStep / FI_INTERVAL * 2 + fieldStep % 2 + CELL_FIELD_BG
                        }

                        //キャラ消去 + 背景変更 + 次のイベントを予約 + イベント読み取り
                        _pushEvents(FALSE, __str("chara,0", NEWLINE, "background,\", alpha, NEWLINE, "reserve_event", NEWLINE, "event_fire,\", nextEvent))

                        //イベントの設定を申請する
                        fieldIdx += 1
                        @if fieldIdx >= FI_CREATE bl {
                            _pushEvents(FALSE, "create_field")
                        }

                        //効果音
                        alpha = rnd(9, 12) * 10
                        @se.play "Move" .opt(80, alpha, 50)

                    //----------------------------
                    //set next
                    } .elif strParam1.eq "reserve_event" bl {
                        //次のイベントを予約する
                        nextEvent = v[__id(fieldHead) + fieldIdx]

                        //条件を満たすと差し替えられる
                        //ボス
                        @if `(fieldStep + 1) % FI_INTERVAL == 0 bl {
                            nextEvent = EV_TYPE_BOSS
                        }
                    //----------------------------
                    //create_field
                    } .elif strParam1.eq "create_field" bl {
                        //進行度に合わせて変える
                        pseudoSwitchState(stageLevel,
                        [0, bl {
                            v[__id(fieldHead)..__id(fieldHead) + FI_CREATE - 1] = FIELD_PATTREN_1
                        },
                        1, bl {
                            v[__id(fieldHead)..__id(fieldHead) + FI_CREATE - 1] = FIELD_PATTREN_2
                        },
                        2, bl {
                            v[__id(fieldHead)..__id(fieldHead) + FI_CREATE - 1] = FIELD_PATTREN_3
                        }
                        ],
                        bl {
                            v[__id(fieldHead) + __id(fieldHead) + FI_CREATE - 1] = 0
                        }
                        )

                        //シャッフル
                        //念のため、2回やる
                        @loop 2 bl {
                            fieldHead .shuffle(FI_CREATE + 1)
                        }

                        //進行度を初期化
                        fieldIdx = 0

                    //----------------------------
                    //event_fire,type
                    } .elif strParam1.eq "event_fire" bl {
                        strParam2 .toNum(alpha)

                        pseudoSwitchState(alpha, 
                        //----------------------------
                        //制御
                        [EV_TYPE_CONTROL, bl {
                            //ランダムメッセージ
                            alpha = rnd(0, 2)
                            $TEXTS =
["のうりょくを ちょうせい
してあげる",
"さいだいHPの ついでに
かいふくも できるわ",
"LVが あがればね
こうげきりょくも ふえる"]
                            __loop $TEXTS $ele $idx bl {
                                @if alpha == $idx bl {
                                    strLine .asg($ele)
                                }
                            }

                            _pushEvents(FALSE, __str("chara,1", NEWLINE, "message,2,2", NEWLINE, "\", strLine, NEWLINE, "close_message"))
                            _initSelectLayer(SELECT_CONTROL)
                            bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_CURSOR)
                            @se.play "Blind" .opt(90, 120, 50)
                        },
                        //----------------------------
                        //行商人
                        EV_TYPE_BUY, bl {
                            //商品を決定する
                            @if stageLevel == 1 bl {
                                SET_GOODS_2
                            } .elif stageLevel == 2 bl {
                                SET_GOODS_3
                            } .else bl {
                                SET_GOODS_1
                            }

                            //値段を決める
                            priceHp = GET_PRICE_HP

                            alpha = rnd(0, 2)
                            $TEXTS =
["HPの かわりに
スキルを あげましょう",
"うぇるかーむ
どうぞ ごゆっくり",
"ほしいのは こころ
おきゃくさまの こころ"]
                            __loop $TEXTS $ele $idx bl {
                                @if alpha == $idx bl {
                                    strLine .asg($ele)
                                }
                            }

                            _pushEvents(FALSE, __str("chara,2", NEWLINE, "message,3,2", NEWLINE, "\", strLine, NEWLINE, "close_message"))
                            _initSelectLayer(SELECT_BUY)
                            bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_CURSOR)
                            @se.play "Item1" .opt(90, 70, 50)
                        },
                        //----------------------------
                        //死体
                        EV_TYPE_CORPSE, bl {
                            //拾えるスキルを決定する
                            //亡者の怒りだが、10%の確率で宝石になる
                            buyItem_1 = rnd(0, 99) < 10 ? SK_JEWEL : SK_RAGE

                            alpha = rnd(0, 2)
                            $TEXTS =
["し、しんでる…
まえにも みたやつだ",
"ハエが たかろうが
おれが つかおうが おなじ",
"あわれな やつだ
やくに たててやろう"]
                            __loop $TEXTS $ele $idx bl {
                                @if alpha == $idx bl {
                                    strLine .asg($ele)
                                }
                            }

                            _pushEvents(FALSE, __str("chara,3", NEWLINE, "message,1,2", NEWLINE, "\", strLine, NEWLINE, "close_message"))
                            _initSelectLayer(SELECT_CORPSE)
                            bitOn(eventFlag, EV_FLAG_SELECT | EV_FLAG_CURSOR)
                            @se.play "bell1" .opt(90, 100, 50)
                        },
                        //----------------------------
                        //戦闘開始
                        EV_TYPE_BATTLE, bl {

                            //敵を決定する
                            //ステージの進行に合わせてパターンが変わる
                            alpha = fieldStep % FI_INTERVAL
                            @if alpha < 10 bl {
                                type = 0
                            } .elif `alpha < FI_INTERVAL / 2 bl {
                                type = rnd(0, 1)
                            } .else bl {
                                type = rnd(1, 2)
                            }

                            @if stageLevel == 1 bl {
                                type = GET_EN_PATTERN_2
                            } .elif stageLevel == 2 bl {
                                type = GET_EN_PATTERN_3
                            } .else bl {
                                type = GET_EN_PATTERN_1
                            }

                            _pushEvents(FALSE, __str("battle_start,\", type))
                        },
                        //----------------------------
                        //ボス戦開始
                        EV_TYPE_BOSS, bl {
                            @if `between(stageLevel, 0, BOSS_NUM - 1) bl {
                                type  = [EN_GROTE, EN_WIND, EN_ANGEL][stageLevel]
                                _pushEvents(FALSE, __str("battle_start,\", type))

                                //イベントを追加する
                                @if stageLevel == 1 bl {
                                    _pushEvents(FALSE, BATTLE_EVENT_2)
                                } .elif stageLevel == 2 bl {
                                    _pushEvents(FALSE, BATTLE_EVENT_3)
                                } .else bl {
                                    _pushEvents(FALSE, BATTLE_EVENT_1)
                                }
                            }
                        }],
                        bl {}
                        )
                    //----------------------------
                    //battle_start,type,level
                    } .elif strParam1.eq "battle_start" bl {
                        strParam2 .toNum(enType)

                        //ステータス設定
                        pseudoSwitchState(enType,
                        [EN_GOBLIN, bl {
                            enLevel = rnd(3, 5)
                            enHp = 4 * enLevel
                            strLine .asg("ゴブりょう")
                        },
                        EN_BANSHEE, bl {
                            enLevel = rnd(5, 9)
                            enHp = 2 * enLevel
                            strLine .asg("バンジー")
                        },
                        EN_ARTIST, bl {
                            enLevel = 8
                            enHp = 5 * enLevel
                            strLine .asg("すごい センス")
                        },
                        EN_GROTE, bl {
                            enLevel = 10
                            enHp = 60
                            strLine .asg("ひと やめたろう")
                        },
                        EN_PLANT, bl {
                            enLevel = rnd(10, 12)
                            enHp = 4 * enLevel
                            strLine .asg("よくばり")
                        },
                        EN_TROOPER, bl {
                            enLevel = 15
                            enHp = 3 * enLevel
                            strLine .asg("ちゅうせい")
                        },
                        EN_ROBOT, bl {
                            enLevel = rnd(8, 10)
                            enHp = 6 * enLevel
                            strLine .asg("ぼうぎょ きこう")
                        },
                        EN_WIND, bl {
                            enLevel = 1 + windLevel * 2
                            enHp = 100
                            strLine .asg("したいの おう")
                        },
                        EN_CUPID, bl {
                            enLevel = 12
                            enHp = 4 * enLevel
                            strLine .asg("もぞう てんし")
                        },
                        EN_MERC, bl {
                            enLevel = rnd(22, 26)
                            enHp = 2 * enLevel
                            strLine .asg("たたかう もの")
                        },
                        EN_WIZARD, bl {
                            enLevel = rnd(12, 16)
                            enHp = 5 * enLevel
                            strLine .asg("ちしきの おり")
                        },
                        EN_ANGEL, bl {
                            enLevel = 20
                            enHp = 200
                            strLine .asg("てんし")
                        } ],
                        bl {}
                        )

                        //ターンカウント
                        battleTurn = 0
                        //カーソルは攻撃ボタンに合わせる
                        cursorPos = 1
                        //表示を更新する
                        bitOn(eventFlag, EV_FLAG_CURSOR | EV_FLAG_SELECT | EV_FLAG_EN_STATUS | EV_FLAG_DESC)
                        //敵を表示する
                        cell = CELL_ENEMY + enType
                        _pushEvents(FALSE, __str("chara,\", cell))
                        _pushLog(__str("\", strLine, " だ！"))
                        //選択肢を戦闘モードに切り替える
                        _initSelectLayer(SELECT_BATTLE)
                        //フラグの初期化
                        battleFlag = 0x00
                        //ボスフラグ
                        @if `enType == EN_GROTE ||
                            enType == EN_WIND ||
                            enType == EN_ANGEL bl {
                            bitOn(battleFlag, BT_FLAG_BOSS)
                            @se.play "Combat2" .opt(100, 100, 50)

                        } .else bl {
                            @se.play "Combat1" .opt(80, 100, 50)
                        }
                    //----------------------------
                    //check_battle_end
                    } .elif strParam1 .eq("check_battle_end") bl {
                        //----------------------------
                        //勝利
                        @if enHp <= 0 bl {
                            @se.play "Collapse2" .opt(100, 100, 50)

                            //キャラ絵を消去する
                            @pic.move[PIC_CHARA] .pos(REF_X, REF_Y) .topLeft .trans(0) .rgbs(200, 200, 200, 10)
                            @wait(0)
                            @pic.move[PIC_CHARA] .relative .pos(0, 0) .scale(0) .trans(100) .time(2) .rgbs(10, 10, 10, 10)
                            @wait(2)

                            //経験値を取得
                            power = enLevel
                            plExp += power
                            _pushLog(__str("かったぜ Exp+\",power))

                            //討伐数カウント
                            overallEnemy += 1

                            //ボス用の勝利イベント
                            @if `battleFlag & BT_FLAG_BOSS bl {
                                @if `between(stageLevel, 0, BOSS_NUM - 1) bl {
                                    __loop [WIN_EVENT_1, WIN_EVENT_2, WIN_EVENT_3] $events $idx bl {
                                        @if stageLevel == $idx bl {
                                            _pushEvents(TRUE, $events)
                                        }
                                    }
                                    //ボスカウント
                                    stageLevel += 1
                                }
                                //勝利イベントの前にレベルアップ判定を行う
                                _pushEvents(FALSE, __str("check_levelup"))

                            //レベルアップ判定のみ
                            } .else bl {
                                _pushEvents(TRUE, __str("check_levelup"))
                            }

                            //通常モードに切り替える
                            _initSelectLayer(SELECT_FIELD)
                            //カーソルを左端に置く
                            cursorPos = 0
                            //敵ステータスを初期化する
                            _initEnemyStatus()
                            //表示
                            bitOn(eventFlag, EV_FLAG_PL_STATUS | EV_FLAG_EN_STATUS | EV_FLAG_DESC | EV_FLAG_SELECT | EV_FLAG_CURSOR)

                        //----------------------------
                        //敗北
                        } .elif plHp <= 0 bl {
                            @wait(6)
                            _pushLog("しんだ")
                            _pushEvents(TRUE, LOSE_EVENT)
                            @se.play "bell1" .opt(90, 80, 50)
                        //----------------------------
                        //戦闘継続
                        } .else bl {
                            //表示
                            bitOn(eventFlag, EV_FLAG_DESC | EV_FLAG_SELECT)
                        }

                    //----------------------------
                    //battle_start_turn,type,special
                    } .elif strParam1 .eq("battle_start_turn") bl {
                        strParam2 .toNum(alpha)
                        strParam3 .toNum(beta)

                        //ターン開始時に増加する
                        battleTurn += 1
                        overallTurn += 1

                        //フラグを初期化する
                        bitOff(battleFlag, BT_FLAG_SPECIAL | BT_FLAG_DEF | BT_FLAG_EN_STUN | BT_FLAG_STUN_1 | BT_FLAG_STUN_2 | BT_FLAG_STUN_3)

                        //攻撃の倍化
                        @if `beta bl {
                            bitOn(battleFlag, BT_FLAG_SPECIAL)
                        }

                        //コマンド
                        _pushEvents(FALSE, __str("battle_player_turn,\", alpha, NEWLINE, "battle_enemy_turn"))

                    //----------------------------
                    //battle_escape
                    } .elif strParam1 .eq("battle_escape") bl {
                        //キャラ絵を消去する
                        @pic.move[PIC_CHARA] .pos(REF_X, REF_Y) .topLeft .trans(100) .time(2) .rgbs(0, 0, 0, 100)
                        //通常モードに切り替える
                        _initSelectLayer(SELECT_FIELD)
                        //カーソルを左端に置く
                        cursorPos = 0
                        //敵ステータスを初期化する
                        _initEnemyStatus()
                        //表示
                        bitOn(eventFlag, EV_FLAG_PL_STATUS | EV_FLAG_EN_STATUS | EV_FLAG_DESC | EV_FLAG_SELECT | EV_FLAG_CURSOR)

                        _pushLog("にげた")
                        @se.play "Escape" .opt(80, 90, 50)

                    //----------------------------
                    //battle_player_turn,skill
                    } .elif strParam1 .eq("battle_player_turn") bl {
                        strParam2 .toNum(type)

                        //強化フラグ
                        alpha = battleFlag & BT_FLAG_SPECIAL
                        //強化用演出
                        @if `alpha bl {
                            @scr.flash .once(1) .rgbv(31, 31, 31, 16)
                        }

                        //----------------------------
                        //技ごとに分岐する
                        pseudoSwitchState(type,
                        //----------------------------
                        //もうじゃの いかり
                        [SK_RAGE, bl {
                            act = ACT_ATTACK
                            //砕くと3倍になる
                            power = plLevel * (alpha ? 3 : 1)
                        },
                        //----------------------------
                        //らいせへの きぼう
                        SK_HOPE, bl {
                            act = ACT_ATTACK
                            //砕いても変化なし
                            power = plLevel
                            bitOn(battleFlag, BT_FLAG_DEF)
                        },
                        //----------------------------
                        //あくま びーむ
                        SK_DEVIL, bl {
                            act = ACT_CURSE
                            //10固定
                            power = 10 * (alpha ? 2 : 1)
                        },
                        //----------------------------
                        //しびれ さーくる
                        SK_CIRCLE, bl {
                            act = ACT_STUN
                            power = plLevel * (alpha ? 2 : 1)
                        },
                        //----------------------------
                        //こんじょう だま
                        SK_SOUL, bl {
                            act = ACT_ATTACK
                            //HPが少ないほど威力が上がる
                            //範囲外だと0倍になる
                            power = muldiv(plLevel * (alpha ? 2 : 1), (plHp < plMaxHp) ? lerp(200, 0, plHp-1, plMaxHp) : (0), 100)
                        },
                        //----------------------------
                        //ひきさきま
                        SK_RIPPER, bl {
                            $HP = 20
                            act = ACT_ATTACK
                            //HPを消費する
                            //足りなくても発動するが威力は1倍になる
                            @if plHp > $HP bl {
                                plHp -= $HP
                                power = muldiv(plLevel * (alpha ? 2 : 1), 250, 100)
                                _pushLog(__str("ちにうえる HP-",$HP))

                            } .else bl {
                                power = plLevel * (alpha ? 2 : 1)
                            }
                        },
                        //----------------------------
                        //せいじん ぼう
                        SK_SAINT, bl {
                            act = ACT_RECOVER
                            //砕くと80回復する
                            power = alpha ? 80 : 5
                        },
                        //----------------------------
                        //ほうせき
                        SK_JEWEL, bl {
                            act = ACT_ATTACK
                            //砕くとかなり威力が上がる
                            power = alpha ? 60 : 5
                        } ],
                        //例外
                        bl {
                            act = ACT_NONE
                        }
                        )

                        //----------------------------
                        pseudoSwitchState(act,
                        //通常攻撃
                        [ACT_ATTACK, bl {
                            //効いてない
                            @if power <= 0 bl {
                                _pushLog(__str("かたい"))
                                @se.play "Sword1" .opt(100, 100, 50)

                            //ダメージ
                            } .else bl {
                                enHp -= power
                                enHp = max(enHp, 0)

                                _pushLog(__str("くらえ！ HP-\",power))
                                @se.play "punch2" .opt(100, 100, 50)

                                _showEnemyDamage(__str("\",power))
                            }

                            //のけぞる
                            @pic.move[PIC_CHARA] .pos(REF_X, REF_Y - 8) .topLeft .rgbs(200, 0, 0, 0)
                            @wait(0)
                            @pic.move[PIC_CHARA] .relative .pos(0, 8) .scale(0) .trans(0) .time(1) .rgbs(100, 100, 100, 100)
                            @wait(2)

                        },
                        //一定確率で痺れる
                        ACT_STUN, bl {
                            //効いてない
                            @if power <= 0 bl {
                                _pushLog(__str("かたい"))
                                @se.play "Sword1" .opt(100, 100, 50)

                            //ダメージ
                            } .else bl {
                                $RND = 30

                                enHp -= power
                                enHp = max(enHp, 0)

                                _showEnemyDamage(__str("\",power))

                                //強化すると確実に痺れる
                                //通常時は30%
                                //ついでにチャージ状態を解除する
                                @if `alpha || rnd(0, 99) < $RND bl {
                                    bitOn(battleFlag, BT_FLAG_EN_STUN)
                                    bitOff(battleFlag, BT_FLAG_EN_CHARGE)

                                    _pushLog(__str("きいてる HP-\",power))
                                } .else bl {
                                    _pushLog(__str("いまいち HP-\",power))
                                }

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

                            //のけぞる
                            @pic.move[PIC_CHARA] .pos(REF_X, REF_Y - 8) .topLeft .rgbs(200, 0, 0, 0)
                            @wait(0)
                            @pic.move[PIC_CHARA] .relative .pos(0, 8) .scale(0) .trans(0) .time(1) .rgbs(100, 100, 100, 100)
                            @wait(2)
                        },
                        //ダメージに加えてレベルが下がる
                        ACT_CURSE, bl {
                            //効いてない
                            @if power <= 0 bl {
                                _pushLog(__str("かたい"))
                                @se.play "Sword1" .opt(100, 100, 50)

                            //ダメージ
                            } .else bl {
                                enHp -= power
                                enHp = max(enHp, 0)
                                _showEnemyDamage(__str("\",power))

                                //レベルを1下げる
                                //強化すると5下げる
                                beta = enLevel
                                enLevel = max(enLevel - (alpha ? 5 : 1), 1)
                                beta -= enLevel
                                
                                @if beta > 0 bl {
                                    _pushLog(__str("のろい HP-\",power, " LV-\",beta))
                                } .else bl {
                                    _pushLog(__str("いまいち HP-\",power))
                                }

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

                            //のけぞる
                            @pic.move[PIC_CHARA] .pos(REF_X, REF_Y - 8) .topLeft .rgbs(200, 0, 0, 0)
                            @wait(0)
                            @pic.move[PIC_CHARA] .relative .pos(0, 8) .scale(0) .trans(0) .time(1) .rgbs(100, 100, 100, 100)
                            @wait(2)
                        },
                        //回復する
                        ACT_RECOVER, bl {
                            //もう回復しない
                            @if plHp < plMaxHp bl {
                                beta = plHp
                                
                                plHp = min(plHp + power, plMaxHp)

                                //回復量
                                beta = plHp - beta

                                _pushLog(__str("かいふく HP+\",beta))
                                @se.play "Recovery3" .opt(100, 100, 50)

                                _showPlayerDamage(__str("\",beta))

                            } .else bl {
                                _pushLog(__str("これいじょうは むり"))
                                @se.play "Sword1" .opt(100, 100, 50)
                            }
                        },
                        //行動不能
                        ACT_NONE, bl {
                            @se.play "Paralyze1" .opt(100, 100, 50)
                            @wait(2)
                        }],
                        bl {}
                        )

                        //勝敗判定を追加
                        _pushEvents(FALSE, __str("check_battle_end"))
                        //ステータス更新
                        bitOn(eventFlag, EV_FLAG_PL_STATUS | EV_FLAG_EN_STATUS)

                    //----------------------------
                    //battle_enemy_turn
                    } .elif strParam1 .eq("battle_enemy_turn") bl {

                        //痺れているときは何もしない
                        @if `battleFlag & BT_FLAG_EN_STUN bl {
                            @se.play "Paralyze1" .opt(100, 100, 50)

                            //光る
                            @pic.move[PIC_CHARA] .pos(REF_X, REF_Y) .topLeft .rgbs(200, 200, 0, 100)
                            @wait(0)
                            @pic.move[PIC_CHARA] .relative .pos(0, 0) .scale(0) .trans(0) .time(1) .rgbs(100, 100, 100, 100)
                            @wait(2)

                        } .else bl {
                            //----------------------------
                            //行動を選択する
                            //最初のターンは1
                            pseudoSwitchState(enType,
                            //常に攻撃
                            [EN_GOBLIN, bl {
                                act = ACT_ATTACK
                            },
                            //攻撃とチャージを交互に。最初がチャージ
                            EN_BANSHEE, bl {
                                act = [ACT_ATTACK, ACT_CHARGE][battleTurn % 2]
                            },
                            //攻撃とスタンを交互に。最初が攻撃
                            EN_ARTIST, bl {
                                act = [ACT_STUN, ACT_ATTACK][battleTurn % 2]
                            },
                            //常に攻撃
                            EN_GROTE, bl {
                                act = ACT_ATTACK
                            },
                            //3ターンに一度スタン
                            EN_PLANT, bl {
                                act = [ACT_STUN, ACT_ATTACK, ACT_ATTACK][battleTurn % 3]
                            },
                            //3ターンに一度チャージ
                            EN_TROOPER, bl {
                                act = [ACT_CHARGE, ACT_ATTACK, ACT_ATTACK][battleTurn % 3]
                            },
                            //スタン、攻撃、チャージ
                            EN_ROBOT, bl {
                                act = [ACT_CHARGE, ACT_STUN, ACT_ATTACK][battleTurn % 3]
                            },
                            //攻撃、スタン
                            EN_WIND, bl {
                                act = [ACT_STUN, ACT_ATTACK][battleTurn % 2]
                            },
                            //常に攻撃
                            EN_CUPID, bl {
                                act = ACT_ATTACK
                            },
                            //4ターンに一度チャージ
                            EN_MERC, bl {
                                act = [ACT_CHARGE, ACT_ATTACK, ACT_ATTACK, ACT_ATTACK][battleTurn % 4]
                            },
                            //攻撃、スタン、スタン
                            EN_WIZARD, bl {
                                act = [ACT_STUN, ACT_ATTACK, ACT_STUN][battleTurn % 3]
                            },
                            //攻撃、スタン、チャージ、スタン
                            EN_ANGEL, bl {
                                act = [ACT_STUN, ACT_ATTACK, ACT_STUN, ACT_CHARGE][battleTurn % 4]
                            } ],
                            //例外
                            bl {
                                act = ACT_NONE
                            }
                            )

                            //----------------------------
                            //効果音
                            pseudoSwitchState(act,
                            [ACT_ATTACK, bl {
                                @se.play "Attack2" .opt(100, 100, 50)
                            },
                            ACT_STUN, bl {
                                @se.play "Thunder4" .opt(100, 100, 50)
                            },
                            ACT_CHARGE, bl {
                                @se.play "Buff" .opt(100, 100, 50)
                            } ],
                            bl {}
                            )

                            //光る
                            @pic.move[PIC_CHARA] .pos(REF_X, REF_Y) .topLeft .rgbs(200, 200, 200, 100)
                            @wait(0)
                            @pic.move[PIC_CHARA] .relative .pos(0, 0) .scale(0) .trans(0) .time(1) .rgbs(100, 100, 100, 100)
                            @wait(2)

                            //----------------------------
                            //攻撃 / スタン
                            @if `act == ACT_ATTACK || act == ACT_STUN bl {
                                //基本攻撃力
                                power = enLevel

                                //チャージ中は一度だけ250%になる
                                @if `battleFlag & BT_FLAG_EN_CHARGE bl {
                                    bitOff(battleFlag, BT_FLAG_EN_CHARGE)
                                    power = muldiv(power, 250, 100)
                                }

                                //無敵モード
                                @if invincibleSwitch.isOn bl {
                                    power = 0

                                //攻撃を遮断する
                                } .elif `battleFlag & BT_FLAG_DEF bl {
                                    @if act == ACT_STUN bl {
                                        //スタン攻撃に対しては防御効果は発揮されない
                                    //強化時は完全に遮断する
                                    } .elif `battleFlag & BT_FLAG_SPECIAL bl {
                                        power = 0
                                    } .else bl {
                                        power /= 2
                                    }
                                }

                                //効いてない
                                @if power <= 0 bl {
                                    _pushLog(__str("  きかん！"))
                                    @se.play "Sword1" .opt(100, 100, 50)

                                //ダメージ
                                } .else bl {
                                    plHp -= power
                                    plHp = max(plHp, 0)

                                    //一部のコマンドが使用不能になる
                                    @if act == ACT_STUN bl {
                                        alpha = rnd(0, 2)
                                        beta = __id(plSkill_1) + alpha

                                        //ランダムに選んだ場所が空白でなければ成功する
                                        @if `v[beta] != SK_NONE bl {
                                            battleFlag |= BT_FLAG_STUN_1 << alpha
                                            _pushLog(__str("  しびれ！ HP-\",power))

                                        } .else bl {
                                            _pushLog(__str("  いたい！ HP-\",power))
                                        }

                                        @scr.shake .once(1) .value(7, 5)
                                        @se.play "Thunder5" .opt(100, 100, 50)

                                    //通常
                                    } .else bl {
                                        _pushLog(__str("  いてぇ！ HP-\",power))
                                        @scr.shake .once(1) .value(7, 5)
                                        @se.play "kick1" .opt(100, 60, 50)
                                    }

                                    //リッチーが死んだ！
                                    @if plHp <= 0 bl {
                                        @se.play "GlassShatter" .opt(80, 80, 50)

                                    //次食らうと死ぬかも
                                    } .elif plHp <= enLevel bl {
                                        @se.play "alert1" .opt(50, 150, 50)
                                    }

                                    //ダメージ表示
                                    _showPlayerDamage(__str("\",power))
                                }
                            //----------------------------
                            //チャージ
                            } .elif act == ACT_CHARGE bl {
                                _pushLog("  ためてる…")
                                bitOn(battleFlag, BT_FLAG_EN_CHARGE)

                                //次食らうと死ぬかも
                                @if `plHp <= muldiv(enLevel, 250, 100) bl {
                                    @se.play "alert1" .opt(50, 150, 50)
                                }
                            }
                        }
                        //勝敗判定を追加
                        _pushEvents(FALSE, __str("check_battle_end" ))
                        //ステータス更新
                        bitOn(eventFlag, EV_FLAG_PL_STATUS | EV_FLAG_EN_STATUS)

                    //----------------------------
                    //check_levelup
                    } .elif strParam1.eq "check_levelup" bl {
                        //レベルアップ回数
                        alpha = 0
                        @loop bl {
                            @if plExp >= plMaxExp bl {
                                //経験値を消費
                                plExp -= plMaxExp
                                //必要な経験値
                                plMaxExp += INC_MAX_EXP
                                //最大HPが増加する
                                plMaxHp += INC_MAX_HP
                                //最大値以下ならば、全回復する
                                @if plHp < plMaxHp bl {
                                    plHp = plMaxHp
                                }
                                //レベルアップ
                                plLevel += 1

                                alpha += 1

                            } .else bl {
                                @break
                            }
                        }

                        //レベルアップ時の演出
                        @if alpha > 0 bl {
                            _pushLog(__str("Level up! Lv+\", alpha))
                            bitOn(eventFlag, EV_FLAG_PL_STATUS)

                            alpha = rnd(0, 2)
                            $TEXTS =
["おれも せいちょう
するんだな",
"わが ちからの まえに
くっするが いいぞ",
"きが たかまる…
あふれるぅ"]
                            __loop $TEXTS $ele $idx bl {
                                @if alpha == $idx bl {
                                    strLine .asg($ele)
                                }
                            }

                            _pushEvents(FALSE, __str("message,1,2", NEWLINE, "\", strLine, NEWLINE, "close_message"))

                            @scr.flash .once(1) .rgbv(31, 31, 31, 16)
                            @se.play "Ice6" .opt(100, 100, 50)
                        }
                    //----------------------------
                    //show_result
                    } .elif strParam1 .eq("show_result") bl {
                        $TEXT = __str("",
"けっか はっぴょう", NEWLINE,
"ターン:\", overallTurn, NEWLINE,
"さいしゅう LV:\", plLevel, NEWLINE,
"たおした てき:\", overallEnemy)

                        _initLog()
                        _pushLog($TEXT)

                    //----------------------------
                    //update_highscore
                    } .elif strParam1 .eq("update_highscore") bl {
                        //ターン数のみで判定する
                        @if `lichWayScore <= 0 || overallTurn < lichWayScore bl {
                            lichWayScore = overallTurn
                        }
                        //実績
                        checkSetAchievement(achievedLich, TRUE)
                    //----------------------------
                    //newline
                    } .elif strParam1 .eq(NEWLINE) bl {
                        //エラーではない
                    //----------------------------
                    //例外
                    } .else bl {
                        db_log(__str("error: \",strLine))
                    }
                }
            } ],
            bl {}
            )

            //----------------------------
            //フラグ
            triggerSwitchState(eventFlag,
            //----------------------------
            //カーソル
            [EV_FLAG_CURSOR, bl {
                ax = CURSOR_X
                ay = CURSOR_Y + cursorPos * CURSOR_SIZE 

                state = v[__id(selectMode_1) + selectLayer]

                //スキルを設置する時のみ、カーソルのセル番号と位置が変化する
                @if state == SELECT_PUT_SKILL bl {
                    ax += 24
                    cell = v[selectParam] + CELL_SKILL
                    @pic.show [PIC_CURSOR] .pos(ax, ay) .cell(cell) .rotate(2) iconPicCmd

                } .else bl {
                    cell = CELL_CURSOR
                    @pic.show [PIC_CURSOR] .pos(ax, ay) .cell(cell) iconPicCmd
                }
            },
            //----------------------------
            //選択用ピクチャを設置する
            //変数も更新している
            EV_FLAG_SELECT, bl {

                //ボタンのセル番号を設定する
                state = v[__id(selectMode_1) + selectLayer]
                pseudoSwitchState(state,
                [SELECT_FIELD, bl {
                    v[__id(selectCell_1)..__id(selectCell_4)] = [CELL_FORWARD,
                            CELL_REPLACE,
                            CELL_NONE,
                            CELL_NONE
                        ]
                },
                SELECT_SORT, bl {
                    v[__id(selectCell_1)..__id(selectCell_4)] = [CELL_BACK,
                        plSkill_1 <= SK_NONE ? (CELL_NONE) : (plSkill_1 + CELL_SKILL),
                        plSkill_2 <= SK_NONE ? (CELL_NONE) : (plSkill_2 + CELL_SKILL),
                        plSkill_3 <= SK_NONE ? (CELL_NONE) : (plSkill_3 + CELL_SKILL)
                    ]
                },
                SELECT_BATTLE, bl {
                    v[__id(selectCell_1)..__id(selectCell_4)] = [(battleFlag & BT_FLAG_BOSS) ? (CELL_NO_ESC) : (CELL_ESCAPE),
                        plSkill_1 <= SK_NONE ? (CELL_NONE) : ((battleFlag & BT_FLAG_STUN_1 ? (SK_AWAIT) : (plSkill_1)) + CELL_SKILL),
                        plSkill_2 <= SK_NONE ? (CELL_NONE) : ((battleFlag & BT_FLAG_STUN_2 ? (SK_AWAIT) : (plSkill_2)) + CELL_SKILL),
                        plSkill_3 <= SK_NONE ? (CELL_NONE) : ((battleFlag & BT_FLAG_STUN_3 ? (SK_AWAIT) : (plSkill_3)) + CELL_SKILL)
                    ]
                },
                SELECT_CONTROL, bl {
                    v[__id(selectCell_1)..__id(selectCell_4)] = [CELL_FORWARD,
                            CELL_REPLACE,
                            CELL_HP_TO_EP,
                            CELL_EP_TO_HP
                    ]
                },
                SELECT_BUY, bl {
                    v[__id(selectCell_1)..__id(selectCell_4)] = [CELL_FORWARD,
                            CELL_REPLACE,
                            buyItem_1 <= SK_NONE ? (CELL_NONE) : (buyItem_1 + CELL_SKILL),
                            buyItem_2 <= SK_NONE ? (CELL_NONE) : (buyItem_2 + CELL_SKILL)
                    ]
                },
                SELECT_PUT_SKILL, bl {
                    v[__id(selectCell_1)..__id(selectCell_4)] = [CELL_BACK,
                        plSkill_1 <= SK_NONE ? (CELL_NONE) : (plSkill_1 + CELL_SKILL),
                        plSkill_2 <= SK_NONE ? (CELL_NONE) : (plSkill_2 + CELL_SKILL),
                        plSkill_3 <= SK_NONE ? (CELL_NONE) : (plSkill_3 + CELL_SKILL)
                    ]
                },
                SELECT_CORPSE, bl {
                    v[__id(selectCell_1)..__id(selectCell_4)] = [CELL_FORWARD,
                            CELL_REPLACE,
                            buyItem_1 <= SK_NONE ? (CELL_NONE) : (buyItem_1 + CELL_SKILL),
                            CELL_GET_EP
                    ]
                } ],
                bl {}
                )
 
                @loop SELECT_NUM .dst(alpha) bl {
                    ax = CURSOR_X
                    ay = CURSOR_Y + alpha * CURSOR_SIZE

                    pid = PIC_SELECT + alpha
                    cell = v[__id(selectCell_1) + alpha]
                    @pic.show [pid] .pos(ax, ay) .cell(cell) iconPicCmd

                }

                //売値を表示する
                @if state == SELECT_BUY bl {
                    @pic.strpic [PIC_PRICE_TEXT] __str("<おねだん>", NEWLINE,"HP \", priceHp, "" ) .pos(PRICE_TEXT_X, PRICE_TEXT_Y) .topLeft normalTextPixCmd 

                //売値を非表示にする
                } .else bl {
                    hidePicture(PIC_PRICE_TEXT)
                }
            },
            //----------------------------
            //説明文を表示する
            EV_FLAG_DESC, bl {
                alpha = v[__id(selectCell_1) + cursorPos]

                __loop DESC_TEXTS $str $idx bl {
                    @if alpha == $idx bl {
                        strLine .asg($str)
                    }
                }
               @pic.strpic [PIC_DESC_TEXT] strLine .pos(DESC_X, DESC_Y) .topLeft normalTextPixCmd
            },
            //----------------------------
            //フィールド
            EV_FLAG_FIELD, bl {
                //ステージ名
                alpha = clamp((fieldStep - 1) / FI_INTERVAL, 0, 2)
                __loop FIELD_NAMES $str $idx bl {
                    @if alpha == $idx bl {
                        strLine .asg($str)
                    }
                }
                //歩数
                strLine .cat(__str(NEWLINE, "Step : \", fieldStep))
                @pic.strpic [PIC_FI_TEXT] strLine .pos(FI_NAME_X, FI_NAME_Y) .topLeft normalTextPixCmd

            },
            //----------------------------
            //プレイヤーのステータス
            EV_FLAG_PL_STATUS, bl {
                @pic.strpic [PIC_PL_TEXT] __str("HP \", plHp, "\c[3] / \c[0]\", plMaxHp, NEWLINE, "LV \", plLevel, NEWLINE, "EXP \", plExp, "\c[3] / \c[0]\", plMaxExp) .pos(PL_STATUS_X, PL_STATUS_Y) .topLeft statusTextPixCmd
            },
            //----------------------------
            //敵のステータス
            EV_FLAG_EN_STATUS, bl {
                @pic.strpic [PIC_EN_TEXT] __str("HP \", enHp, NEWLINE, "LV \", enLevel ) .pos(EN_STATUS_X, EN_STATUS_Y) .topLeft statusTextPixCmd
            },
            //----------------------------
            //ログ
            EV_FLAG_LOG, bl {
                //ログを消去する
                @if logCount > LOG_COUNT bl {
                    @while logCount > LOG_COUNT bl {
                        logCount -= 1
                        strLog .popLine(strLine)
                    }

                    @pic.strpic [PIC_LOG_TEXT] strLog .pos(LOG_X, LOG_Y + 12) .topLeft normalTextPixCmd
                    @pic.move [PIC_LOG_TEXT] .relative .pos(0, -12) .scale(0) .trans(0) .time(1)

                } .else bl {
                    @pic.strpic [PIC_LOG_TEXT] strLog .pos(LOG_X, LOG_Y) .topLeft normalTextPixCmd
                }
            },
            //----------------------------
            //カーソル音
            EV_FLAG_SE_CURSOR, bl {
                @se.play "Cursor1" .opt(60, 60, 50)
            },
            //----------------------------
            //決定音
            EV_FLAG_SE_DECISION, bl {
                @se.play "Decision1" .opt(70, 100, 50)
            },
            //----------------------------
            //キャンセル音
            EV_FLAG_SE_CANCEL, bl {
                @se.play "Cancel1" .opt(80, 100, 50)
            } ] )
        }
    }

    //------------------------------------------------------------------------------------
    //終了する
    @label.set "gameEnd"
    bl {
        //天候初期化
        @scr.weather .none .medium

        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, TS_MINIGAME, NUM_OF_STR)
        restoreBGM()
        fastFadeInTintOnly(1)
    }
}
