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


cev[CEV_DRAGOPH] .name("mg_ドラゴフィ") {

    def {
        NUM_OF_VAR = 128
        NUM_OF_STR = 1
        NUM_OF_PIC = 48

        BASE_LAYER = 6

        PATH_BACK   = "dp\ba"
        PATH_WINDOW = "cm\da"
        PATH_RESULT = "dp\re"
        PATH_CURSOR = "dp\cu"
        PATH_CARD   = "dp\ca"

        //ピクチャID
        PIC_HEAD = 1
        PIC_BACK = 5
        PIC_DECK = 6
        PIC_DECK_COUNTER = 7
        PIC_DECK_NAME = 8
        PIC_FIELD = 13//+0_+4
        PIC_HAND = 18//+0_+9
        PIC_EVENT_WINDOW = 30
        PIC_EVENT_CARD   = 31//+0_+4
        PIC_RESULT       = 36
        PIC_EVENT_TEXT   = 37
        PIC_CURSOR       = 38
        PIC_EXPLAN_WINDOW = 39
        PIC_EXPLAN_TEXT   = 40
        PIC_ABOVE_WINDOW  = 41
        PIC_ABOVE_TEXT    = 42

        //シーン
        SCENE_CHOICE_ACTIVATE = 0
        SCENE_CONFIRM
        SCENE_CHOICE_HAND
        SCENE_CHOICE_FIELD
        SCENE_ACTIVE
        SCENE_JUDGE
        SCENE_RESULT
        SCENE_DECK_BACK
        SCENE_STACK

        //トリガー
        TR_TEXT_SMALL  = (1 << 0)//カードの短い説明文を表示する
        TR_TEXT_NORMAL = (1 << 1)//カードの説明文を表示する
        TR_TEXT_ABOVE  = (1 << 2)//操作ガイドを表示する
        TR_CHG_CURSOR  = (1 << 3)//選択位置が変わった
        TR_SE_ACTIVE   = (1 << 4)//効果音 
        TR_SE_DISPOSE  = (1 << 5)
        TR_SE_CURSOR   = (1 << 6)
        TR_SE_DECISION = (1 << 7)
        TR_SE_CANCEL   = (1 << 8)

        //スタック
        STACK_POP = 0
        STACK_ADD_DECK
        STACK_BACK_DECK
        STACK_SHUFFLE_DECK
        STACK_REMOVE_DISPOSE
        STACK_REPLACE_CHARM
        STACK_DRAW
        STACK_PACK_HAND
        STACK_ADD_HAND
        STACK_REMOVE_HAND
        STACK_ADD_MONSTER
        STACK_REMOVE_MONSTER

        //結果
        RESULT_LOSE = 0
        RESULT_WIN
        RESULT_SPECIAL

        //ゲームモード
        CONDITIONS_NORMAL = 0//ドラゴン1体を作る
        CONDITIONS_FULL//ドラゴンを4体つくる

        //操作ガイド
        ACTIVE_NONE = 0
        ACTIVE_DISPOSE
        ACTIVE_NORMAL
        ACTIVE_SEL_TAG_HAND
        ACTIVE_SEL_DIS_HAND
        ACTIVE_SEL_TAG_MONSTER
        ACTIVE_SEL_DIS_MONSTER

        //デッキタイプ
        DECK_NONE = 0
        DECK_NORMAL
        DECK_SMALL
        DECK_CIVILWAR
        DECK_RUIN

        //カードの種類
        CARD_NONE = 0//なし
        CARD_STAG//淀み
        CARD_MULTI//増殖
        CARD_SUMMON//召喚
        CARD_RAISE//底上げ
        CARD_UNION//合体
        CARD_DUNGEON//迷宮
        CARD_TYRANNY//圧制
        CARD_CHARM//魅了
        CARD_PLUNDER//略奪
        CARD_SABOTAGE//破壊工作
        CARD_DOWNHILL//下剋上
        CARD_REBELLION//反乱鎮圧
        CARD_FORCE//討伐隊
        CARD_BRAVE//勇者

        //定数
        OUT_RANGE    = -320
        INPUT_REPEAT = 10
        WINDOW_TRANS = 30
        TEXT_MARGIN  = 8
        FLUSH_INTERVAL = 30//選択カードの点滅間隔
        EVENT_CENTER_X = 160//イベント時のピクチャの基準位置
        EVENT_CENTER_Y = 120

        DECK_X = 288//山札
        DECK_Y = 150
        DISPOSE_X = 360//画面外の札置き場
        DISPOSE_Y = 100
        DECK_CELL = 39

        DECK_NAME_X = 288 //デッキの名前
        DECK_NAME_Y = 12

        HAND_X = 40//手札
        HAND_Y = 168
        HAND_WIDTH = 58//手札の整列
        HAND_WIDTH_NUM = 4

        FIELD_X = 48//場
        FIELD_Y = 56
        FIELD_WIDTH = 58

        LEVEL_MAX  = 7//魔物の最大LV
        BRAVE_MAX  = 8//勇者の最大追加数
        BRAVE_CELL = 14

        STACK_SIZE = 8//スタックの最大数
        DECK_SIZE  = 30//デッキの最大枚数
        HAND_SIZE  = 8//手札の最大枚数
        HAND_LIMIT = 4//手札の標準枚数
        FIELD_SIZE = 4//場の最大枚数

        //キー入力
        CHK_DECISION = (iptDecision == 1 || (iptVCounter == 1 && iptV < 0))
        CHK_CANCEL   = (iptCancel   == 1 || (iptVCounter == 1 && iptV > 0))
    }
    
    def {
        basePicCmd = {
            .chromakey(1)
            .mapLayer(BASE_LAYER)
            .eraseWhenTransfer
            .affectedByTint
            .affectedByFlash
            .affectedByShake
        }

        normalStrPicCmd = {
            .font("", 12)
            .spacing(0, 4)
            .skin "" .nobg .noframe .noPadding
            basePicCmd
        }

        boldStrPicCmd = {
            .font("", 12)
            .spacing(0, 4)
            .skin "" .nobg .noframe .noPadding .bold
            basePicCmd
        }

        cursorPicCmd = {
            PATH_CURSOR
            .grid(2, 1)
            basePicCmd
        }

        windowPicCmd = {
            PATH_WINDOW
            basePicCmd
        }

        cardPicCmd = {
            PATH_CARD
            .grid(8, 5)
            basePicCmd
        }

        resultPicCmd = {
            PATH_RESULT
            .grid(1, 3)
            basePicCmd
        }
    }

    defv {
        varHead = TV_MINIGAME
        
        ipt
        pid
        cell
        flag
        idxA
        eleA
        idxB
        eleB
        sx
        sy
        ex
        ey
        ftA

        deckType

        initHead//初期化対象の先頭

        iptDecision
        iptCancel
        iptH
        iptHCounter
        iptV
        iptVCounter

        sceneState
        sceneTimer
        triggerFlg

        stackNum
        stackState
        stackParam
        stackDelay
        stackTimer

        deckNum
        deckSize

        handNum
        braveHandNum

        fieldNum
        availableUnion
        maxFieldLevel
        minFieldLevel

        activeIdx
        activeType
        activeMode

        chooseReq
        chooseNum
        chooseIdx
        chooseBit
        chooseType
        chooseLevel
        chooseFirst

        explanType
        aboveType
        ClearConditions
        result
        round
        dragonScore
        usedScore
        score

        stackArr
        deckArr   = __id(stackArr) + STACK_SIZE
        handArr   = __id(deckArr)  + DECK_SIZE
        fieldArr  = __id(handArr)  + HAND_SIZE
        varFoot = __id(fieldArr) + FIELD_SIZE//初期化対象の最後尾
    }

    deft {
        strLine = TS_MINIGAME
    }

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

    //----------------------------
    //配列の中身を表示する。デバグ用
    //idxA, eleA, strLineを使用する
    __fn _showArray $head $size bl {
        strLine .asg("\>")

        @loop $size .dst(idxA) bl {
            readFromArray(eleA, $head, idxA)

            strLine .cat(__str("\",eleA, ",") .extract)
            @if `(idxA + 1) % 12 == 0 bl {
                strLine .cat(__str(NEWLINE, "\>"))
            }
        }

        @msg.show strLine
    }

    //----------------------------
    //データ数のチェックは行わない
    //スタックにデータを追加する
    //使える範囲はそれぞれ0_255. 0_65536, 0_255
    __fn _pushStack $state $param $delay bl {
        v[__id(stackArr) + stackNum] = (($state) & 0xff) | ((($param) & 0xffff) << 8) | ((($delay) & 0xff) << 24)
        stackNum += 1
    }

    //スタックからデータを取得する
    __fn _popStack $dvState $dvParam $dvDelay bl {
        stackNum -= 1

        ftA = v[__id(stackArr) + stackNum]
        v[__id($dvState)] = ftA & 0xff
        v[__id($dvParam)] = (ftA >> 8) & 0xffff
        v[__id($dvDelay)] = (ftA >> 24) & 0xff
    }

    //スタック処理の状態を変える
    __fn _setStackState $state $param $delay bl {
        v[__id(stackState)..__id(stackTimer)] = [$state, $param, $delay, -1]
    }

    //スタックを初期化する
    __fn _initStack bl {
        stackNum = 0
    }

    //----------------------------
    //手札のピクチャIDを取得する
    __fn _getHandPicture $dvDst $idx bl {
        v[__id($dvDst)] = PIC_HAND + (HAND_SIZE - 1 - ($idx))
    }

    //手札のセル番号を取得する
    __fn _getHandCell $dvDst $type bl {
        v[__id($dvDst)] = ($type)
    }

    //手札の位置を算出する(中心)
    __fn _V2_getHandPosition $dvVec $idx bl {
        v[__id($dvVec)..__id($dvVec) + 1] =
        [HAND_X + ($idx) * (handNum > HAND_WIDTH_NUM ? (HAND_WIDTH * HAND_WIDTH_NUM / handNum) : (HAND_WIDTH)),
        HAND_Y]
    }

    //----------------------------
    //魔物のLVを取得する
    __fn _getMonsterLevel $dvDst $type bl {
        v[__id($dvDst)] = (($type) > 0) ? ((($type) + 2) / 3) : 0
    }

    //魔物のピクチャIDを取得する
    __fn _getMonsterPicture $dvDst $idx bl {
        v[__id($dvDst)] = PIC_FIELD + (FIELD_SIZE - 1 - ($idx))
    }

    //魔物のセル番号を取得する
    __fn _getMonsterCell $dvDst $type bl {
        v[__id($dvDst)] = ($type) + 16
    }

    //魔物の位置を算出する(中心)
    __fn _V2_getMonsterPosition $dvVec $idx bl {
        v[__id($dvVec)..__id($dvVec) + 1] =
        [FIELD_X + ($idx) * FIELD_WIDTH,
        FIELD_Y]
    }

    //----------------------------
    //短い説明文を表示する
    __fn _showShortExplan $type bl {
        explanType = $type
        bitOn(triggerFlg, TR_TEXT_SMALL)
    }

    //通常の説明文を表示する
    __fn _showLongExplan $type bl {
        explanType = $type
        bitOn(triggerFlg, TR_TEXT_NORMAL)
    }

    //操作ガイドを表示する
    __fn _showAboveExplan $type bl {
        aboveType = $type
        bitOn(triggerFlg, TR_TEXT_ABOVE)
    }

    //----------------------------
    //シーンの状態を変える
    __fn _changeSceneState $state bl {
        v[__id(sceneState)..__id(sceneTimer)] = [$state, -1]
    }

    //ハイスコアを更新する
    __fn _updateHighScore bl {
        dragophScore = max(dragophScore, score)
    }

    //----------------------------
    //カード情報

    //操作ガイド
    $ABOVE_TEXTS = ["",
"\c[7]発動不可 : 決定キーを押して、カードを捨てます",
"\c[2]発動可能 : 決定キーを押して、効果を発動します",
__str("手札から対象となるカードを \c[2]\", chooseReq ,"\c[0]枚 選んでください"),
__str("手札から捨てるカードを \c[2]\", chooseReq ,"\c[0]枚 選んでください"),
__str("場から対象となるカードを \c[2]\", chooseReq ,"\c[0]枚 選んでください"),
__str("場から捨てるカードを \c[2]\", chooseReq ,"\c[0]枚 選んでください"),
]

    //短い説明文
    $SHORT_TEXTS = ["",
"ＬＶ１の魔物を１体置く",
"同じＬＶの魔物を１体置く",
"ＬＶが１小さい魔物を２体置く",
"ＬＶが最小の魔物のＬＶを上げる",
"魔物２体でＬＶが１大きい魔物を１体置く",
"手札を１枚捨てる",
"手札を１枚追放する",
"捨てたカードが後で増える",
"魔物が１体のみの時、山札から２枚引く",
"魔物が３体以上いる時、手札を全て捨てる",
"魔物１体のＬＶを下げる",
"ＬＶが同じ魔物を全て捨てる",
"魔物が２体になるように捨てる",
"魔物を１体捨てる" ]

    //説明文
    $LONG_TEXTS =["",
"\c[2][ 淀み ]\c[0]
場にＬＶ１の魔物を１体置く。",
"\c[2][ 増殖 ]\c[0]
場にある魔物を１体選ぶ。
同じ魔物を１体置く。",
"\c[2][ 召喚 ]\c[0]
ＬＶが２以上の魔物を１体選ぶ。
その魔物よりもＬＶが１小さい
魔物を２体置く。",
"\c[2][ 底上げ ]\c[0]
場にある最もＬＶが小さい魔物を１体選ぶ。
その魔物のＬＶを１上げる。
全ての魔物のＬＶが同じだと発動できない。",
"\c[2][ 合体 ]\c[0]
場にあるＬＶが同じ魔物を２体選ぶ。
その魔物を捨て、ＬＶが１つ大きい魔物を置く。",
"\c[2][ 迷宮建設 ]\c[0]
手札からカードを１枚選ぶ。
そのカードを捨てる。",
"\c[2][ 圧制 ]\c[0]
手札からカードを１枚選ぶ。そのカードを捨てる。
発動したこのカードと捨てられたカードは
以降のラウンドで現れない。",
"\c[2][ 魅了 ]\c[0]
手札からカードを１枚選ぶ。そのカードを捨てる。
捨てられたカードは次のラウンドで２枚に増える。
発動したこのカードは以降のラウンドで現れない。",
"\c[2][ 略奪 ]\c[0]
魔物が場に１体しかいないとき、
カードを２枚引く。
手札はこのカードを含めて８枚までとなる。",
"\c[2][ 破壊工作 ]\c[0]
魔物が場に３体以上いるとき、
手札を全て捨てる。",
"\c[2][ 下剋上 ]\c[0]
ＬＶが２以上の魔物を１体選ぶ。
その魔物のＬＶを１つ下げる。",
"\c[2][ 反乱鎮圧 ]\c[0]
魔物を１体選ぶ。
その魔物と同じＬＶの魔物を全て捨てる。",
"\c[2][ 討伐隊 ]\c[0]
場にいる魔物が２体になるまで魔物を捨てる。",
"\c[2][ 勇者 ]\c[0]
場にある魔物を１体選ぶ。
その魔物を捨てる。" ]

//()で括らないとエラーが出る
//発動できるかをチェックする
//手札の枚数には発動するカードも含まれる
$CHECK_ACTIVATABLE = [ ACTIVE_DISPOSE,
(fieldNum < FIELD_SIZE) ? (ACTIVE_NORMAL) : ACTIVE_DISPOSE,//淀み:場に空きがある
between(fieldNum, 1, FIELD_SIZE - 1) ? (ACTIVE_SEL_TAG_MONSTER) : ACTIVE_DISPOSE,//増殖:魔物が1体以上で、場の空きがある
(fieldNum < FIELD_SIZE && maxFieldLevel >= 2) ? (ACTIVE_SEL_TAG_MONSTER) : ACTIVE_DISPOSE,//召喚:場に空きがあり、最大LVが2以上
(fieldNum >= 1 && maxFieldLevel > minFieldLevel) ? (ACTIVE_SEL_TAG_MONSTER) : ACTIVE_DISPOSE,//底上げ:魔物が１体以上で、最大LVが最小LVよりも大きい
(availableUnion) ? (ACTIVE_SEL_TAG_MONSTER) : ACTIVE_DISPOSE,//合体:LVが1以上かつ最大LVより低い魔物が2体以上いる
(handNum >= 2) ? (ACTIVE_SEL_DIS_HAND) : ACTIVE_DISPOSE,//迷宮建設:手札が2枚以上ある
//(handNum - braveHandNum >= 2) ? (ACTIVE_SEL_DIS_HAND) : ACTIVE_DISPOSE,//圧制:勇者以外の手札が2枚以上ある
(handNum >= 2) ? (ACTIVE_SEL_DIS_HAND) : ACTIVE_DISPOSE,//圧制:手札が2枚以上ある
(handNum >= 2) ? (ACTIVE_SEL_TAG_HAND) : ACTIVE_DISPOSE,//魅了:手札が2枚以上ある
(fieldNum == 1 && handNum < HAND_SIZE && deckNum >= 1) ? (ACTIVE_NORMAL) : ACTIVE_DISPOSE,//略奪:魔物が1体いて、手札の数が最大値よりも少なく、デッキの残りが1枚以上
(fieldNum >= 3 && handNum >= 2) ? (ACTIVE_NORMAL) : ACTIVE_DISPOSE,//破壊工作:魔物が3体以上いて、手札の数が2枚以上
(fieldNum >= 1 && maxFieldLevel >= 2) ? (ACTIVE_SEL_TAG_MONSTER) : ACTIVE_DISPOSE,//下剋上:魔物が1体以上いて、最大LVが2以上
(fieldNum >= 1) ? (ACTIVE_SEL_TAG_MONSTER) : ACTIVE_DISPOSE,//反乱鎮圧:魔物が1体以上いて、最大LVが最小LVよりも大きい
(fieldNum >= 3) ? (ACTIVE_SEL_DIS_MONSTER) : ACTIVE_DISPOSE,//討伐隊:魔物が3体以上いる
(fieldNum >= 1) ? (ACTIVE_SEL_DIS_MONSTER) : ACTIVE_DISPOSE//勇者:魔物の数が1以上
][activeType]

//選ぶ枚数
//過不足なく選ばないといけない
$CHOOSE_NUM = [0,
0,//淀み
1,//増殖
1,//召喚
1,//底上げ
2,//合体
1,//迷宮建設
1,//圧制
1,//魅了
0,//略奪
0,//破壊工作
1,//下剋上
1,//反乱鎮圧
fieldNum - 2,//討伐隊
1//勇者
][activeType]

//選択時の判定
//空白と発動するカードは選択できない
$CHOICE_CARD = [ FALSE,
TRUE,//淀み
TRUE,//増殖
(chooseLevel >= 2) ? (TRUE) : FALSE,//召喚:LVが2以上
(chooseLevel <= minFieldLevel) ? (TRUE) : FALSE,//底上げ:LVが最低LV以下
(chooseFirst <= 0 || chooseFirst == chooseLevel) ? (TRUE) : FALSE,//合体:1体目に選んだ魔物と同LV
TRUE,//迷宮建設
//(chooseType != CARD_BRAVE),//圧制:勇者以外
TRUE,//圧制:勇者以外
TRUE,//魅了
TRUE,//略奪
TRUE,//破壊工作
(chooseLevel >= 2) ? (TRUE) : FALSE,//下剋上:LVが2以上
TRUE,//反乱鎮圧
TRUE,//討伐隊
TRUE//勇者
][activeType]

//発動時の処理
$ACTIVE_CARD = [ bl {},
bl {
    //淀み
    eleA = rnd(1, 3)
    _pushStack(STACK_ADD_MONSTER, eleA, 0)
},
bl {
    //増殖
    eleA = chooseType
    _pushStack(STACK_ADD_MONSTER, eleA, 0)
},
bl {
    //召喚
    @loop 2 bl {
        eleA = clamp(chooseFirst - 1, 1, LEVEL_MAX)
        eleA = (eleA - 1) * 3 + rnd(1, 3)
        _pushStack(STACK_ADD_MONSTER, eleA, 8)
    }
},
bl {
    //底上げ
    eleA = clamp(chooseFirst + 1, 1, LEVEL_MAX)
    eleA = (eleA - 1) * 3 + rnd(1, 3)
    _pushStack(STACK_ADD_MONSTER, eleA, 8)
    _pushStack(STACK_REMOVE_MONSTER, chooseBit, 0)
},
bl {
    //合体
    eleA = clamp(chooseFirst + 1, 1, LEVEL_MAX)
    eleA = (eleA - 1) * 3 + rnd(1, 3)
    _pushStack(STACK_ADD_MONSTER, eleA, 8)
    _pushStack(STACK_REMOVE_MONSTER, chooseBit, 0)
},

bl {
    //迷宮建設
    _pushStack(STACK_REMOVE_HAND, chooseBit, 0)
},
bl {
    //圧制
    _pushStack(STACK_REMOVE_HAND, chooseBit, 8)
    _pushStack(STACK_REMOVE_DISPOSE, chooseType, 0)
    _pushStack(STACK_REMOVE_DISPOSE, activeType, 0)
},
bl {
    //魅了
    _pushStack(STACK_REMOVE_HAND, chooseBit, 8)
    _pushStack(STACK_REPLACE_CHARM, chooseType, 0)
},
bl {
    //略奪
    _pushStack(STACK_DRAW, 2, 0)
},
bl {
    //破壊工作
    //発動カードを除く全てのカード
    idxB = 0x00
    @loop HAND_SIZE .dst(idxA) bl{
        readFromArray(eleA, handArr, idxA)
        @if idxA != activeIdx bl {
            idxB |= 1 << idxA
        }
    }

    _pushStack(STACK_REMOVE_HAND, idxB, 0)

},
bl {
    //下剋上
    eleA = clamp(chooseFirst - 1, 1, LEVEL_MAX)
    eleA = (eleA - 1) * 3 + rnd(1, 3)
    _pushStack(STACK_ADD_MONSTER, eleA, 8)
    _pushStack(STACK_REMOVE_MONSTER, chooseBit, 0)
},
bl {
    //反乱の鎮圧
    idxB = 0x00
    @loop FIELD_SIZE .dst(idxA) bl{
        readFromArray(eleA, fieldArr, idxA)
        _getMonsterLevel(eleA, eleA)
        @if chooseFirst == eleA bl {
            idxB |= 1 << idxA
        }
    }

    _pushStack(STACK_REMOVE_MONSTER, idxB, 0)
},
bl {
    //討伐隊
    _pushStack(STACK_REMOVE_MONSTER, chooseBit, 0)
},
bl {
    //勇者
    _pushStack(STACK_REMOVE_MONSTER, chooseBit, 0)
}
]

    //------------------------------------------------------------------------------------
    //開始処理
    bl {
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, TS_MINIGAME, NUM_OF_STR)
        msgBottom()
        
        //ピクチャ
        @pic.show [PIC_BACK] PATH_BACK .pos(0, 0) .topLeft basePicCmd
        //説明文
        @pic.show [PIC_EXPLAN_WINDOW] PATH_WINDOW .pos(OUT_RANGE, OUT_RANGE) .trans(100) .multi basePicCmd
        @pic.show [PIC_ABOVE_WINDOW] PATH_WINDOW .pos(OUT_RANGE, OUT_RANGE) .trans(100) .multi basePicCmd
        //カーソル
        @pic.show [PIC_CURSOR] .pos(OUT_RANGE, OUT_RANGE) .trans(100) .cell(0) cursorPicCmd
        //イベント
        @pic.show [PIC_RESULT] .pos(OUT_RANGE, OUT_RANGE) .trans(100) .cell(0) resultPicCmd
        @pic.show [PIC_EVENT_WINDOW] .pos(OUT_RANGE, OUT_RANGE) .trans(100) windowPicCmd
        @loop 5 .dst(pid) bl {
            pid += PIC_EVENT_CARD
            @pic.show [pid] .pos(OUT_RANGE, OUT_RANGE) .cell(0) .trans(100) cardPicCmd
        }

        fastFadeInTintOnly(1)
        @wait(1)

        @label.jump "gameLoop"
    }

    //------------------------------------------------------------------------------------
    //ゲーム処理
    @label.set "gameLoop"
    bl {
        //----------------------------
        //ピクチャを初期化する
        hidePicturesForEach( [ PIC_DECK, PIC_DECK_COUNTER, PIC_DECK_NAME, PIC_RESULT, PIC_EVENT_WINDOW, PIC_EVENT_TEXT ] )
        @loop 5 .dst(pid) bl {
            pid += PIC_EVENT_CARD
            hidePicture(pid)

        }
        @loop HAND_SIZE .dst(pid) bl {
            pid += PIC_HAND
            hidePicture(pid)

        }
        @loop FIELD_SIZE .dst(pid) bl {
            pid += PIC_FIELD
            hidePicture(pid)
            
        }
        //変数を一括で初期化する
        assignVarUsingDeclared(initHead, varFoot, 0)
        //代入
        ClearConditions = CONDITIONS_NORMAL
        round = 1
        //----------------------------
        //デッキ選択へ
        //キャンセルするとゲームを終了する
        @if deckType <= 0 bl {
            @msg.choice bl {
                .case "\>通常デッキ" bl {
                    deckType = DECK_NORMAL
                }
                .case "\>最小デッキ(勇者を除き各１枚ずつ)" bl {
                    deckType = DECK_SMALL
                }
                .case "\>内乱デッキ(反乱鎮圧と魅了が多い)" bl {
                    deckType = DECK_CIVILWAR
                }
                .case "\>破滅デッキ(増殖と圧制がなく、勇者１枚入り)" bl {
                    deckType = DECK_RUIN
                }
                .cancel bl {
                    @label.jump "gameEnd"
                }
            }
        }

        //----------------------------
        //デッキを入力し、表示する
        //最小デッキ
        //勇者以外の全てのカードが1枚ずつ入っている
        @if deckType == DECK_SMALL bl {
            strLine.asg("\c[2][ 最小 ]")
            deckSize = 13
            copyToArray(deckArr, deckSize,
                [ CARD_STAG,     CARD_MULTI,
                  CARD_SUMMON,   CARD_RAISE,
                  CARD_UNION,    CARD_CHARM,
                  CARD_DUNGEON,  CARD_TYRANNY,
                  CARD_PLUNDER,  CARD_SABOTAGE,
                  CARD_DOWNHILL, CARD_REBELLION,
                  CARD_FORCE ]
            )

        //内乱デッキ
        //反乱と魅了が多い
        } .elif deckType == DECK_CIVILWAR bl {
            strLine.asg("\c[2][ 内乱 ]")
            deckSize = 18
            copyToArray(deckArr, deckSize,
                [ CARD_MULTI,     CARD_CHARM,
                  CARD_UNION,     CARD_UNION,
                  CARD_SUMMON,    CARD_SUMMON,
                  CARD_RAISE,     CARD_PLUNDER,
                  CARD_DUNGEON,   CARD_TYRANNY,   
                  CARD_CHARM,     CARD_CHARM,
                  CARD_DOWNHILL,  CARD_DOWNHILL,
                  CARD_REBELLION, CARD_REBELLION,
                  CARD_REBELLION, CARD_FORCE ]
            )

        //破滅デッキ
        //増殖と圧制がなく、勇者が1枚入っている
        } .elif deckType == DECK_RUIN bl {
            strLine.asg("\c[2][ 破滅 ]")
            deckSize = 16
            copyToArray(deckArr, deckSize,
                [ CARD_UNION,     CARD_UNION,
                  CARD_RAISE,     CARD_STAG,
                  CARD_SUMMON,    CARD_SUMMON,
                  CARD_DUNGEON,   CARD_DUNGEON,  
                  CARD_CHARM,     CARD_SABOTAGE,
                  CARD_PLUNDER,   CARD_DOWNHILL,
                  CARD_REBELLION, CARD_BRAVE,
                  CARD_FORCE,     CARD_FORCE ]
            )

        //通常デッキ
        //合体、下剋上、討伐隊が2枚ずつ
        } .else bl {
            strLine.asg("\c[2][ 通常 ]")
            deckSize = 16
            copyToArray(deckArr, deckSize,
                [ CARD_MULTI,
                  CARD_UNION,    CARD_UNION,
                  CARD_STAG,     CARD_SUMMON,
                  CARD_RAISE,
                  CARD_DUNGEON,  CARD_TYRANNY,
                  CARD_CHARM,    CARD_REBELLION,
                  CARD_PLUNDER,  CARD_SABOTAGE,
                  CARD_DOWNHILL, CARD_DOWNHILL,
                  CARD_FORCE,    CARD_FORCE ]
            )
        }
        //デッキ名
        @pic.strpic [PIC_DECK_NAME] strLine .pos(DECK_NAME_X, DECK_NAME_Y) .center normalStrPicCmd 

        //残りデッキ枚数
        deckNum = deckSize
        //_showArray(deckArr, deckSize)
        //----------------------------
        //スタックにデータを積む
        //ドロー
        _pushStack(STACK_DRAW, HAND_LIMIT, 8)//8f遅延
        //デッキをシャッフルする
        _pushStack(STACK_SHUFFLE_DECK, 0, 0)
        //LV1の魔物を2体だけ置く
        @loop 2 bl {
            eleA = rnd(1, 3)
            _pushStack(STACK_ADD_MONSTER, eleA, 4)
        }

        //最初にスタックを崩す
        _changeSceneState(SCENE_STACK)
        
        //----------------------------
        //ループ
        @loop bl {
            @wait(0)

            //----------------------------
            //入力
            @key.input .dst(ipt) .decision
            iptDecision = ipt ? iptDecision + 1 : 0
            @key.input .dst(ipt) .cancel
            iptCancel = ipt ? iptCancel + 1 : 0
            @key.input .dst(ipt) {
                .left
                .right
            }
            iptH = ipt == KEY_LEFT ? -1 : 1
            iptHCounter = ipt ? iptHCounter + 1 : 0
            @key.input .dst(ipt) {
                .up
                .down
            }
            iptV = ipt == KEY_UP ? -1 : 1
            iptVCounter = ipt ? iptVCounter + 1 : 0

            //----------------------------
            //メニュー / やり直し
            //手札を選択する時のみ有効
            @if `iptCancel == 1 && sceneState == SCENE_CHOICE_ACTIVATE bl {
                @se.play "Cancel2" .opt(100, 100, 50)
                @msg.choice bl {
                    .cancel(0)
                    .case "\>つづける" bl {
                        @wait(3)
                    }
                    .case "\>\c[2]やりなおす\c[0]" bl {
                        @label.jump "gameLoop"
                    }
                    .case "\>\c[2]デッキを変える\c[0]" bl {
                        deckType = DECK_NONE
                        @label.jump "gameLoop"
                    }
                    .case "\>やめる" bl {
                        @label.jump "gameEnd"
                    }
                }
            }

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

            //----------------------------
            //効果を発動するカードを選ぶ
            @if sceneState == SCENE_CHOICE_ACTIVATE bl {
                //最初のフレーム
                @if sceneTimer == 0 bl {
                    bitOn(triggerFlg, TR_CHG_CURSOR)
                    //選択状態を初期化する
                    activeIdx  = clamp(activeIdx, 0, handNum - 1)
                    activeType = CARD_NONE
                    //選択中のカードの種類とピクチャ
                    //事前に手札の空きや枚数を処理する為、空白である事は想定していない
                    readFromArray(activeType, handArr, activeIdx)
                    //上の字幕を消す
                    _showAboveExplan(ACTIVE_NONE)
                    //短い説明文を表示する
                    _showShortExplan(activeType)
                }

                //一応、チェックはしておく
                @if activeType == CARD_NONE bl {
                    __str("Error: 空白を選択しています : \", activeIdx)
                    @label.jump "gameEnd"
                }

                //発動するカードを決定する
                @if `CHK_DECISION bl {
                    //空白ではない
                    @if activeType != CARD_NONE bl {
                        bitOn(triggerFlg, TR_SE_DECISION)
                        //カードの種類によって異なる
                        activeMode = $CHECK_ACTIVATABLE
                        //カードによっては確認なしで発動する
                        //手札選択へ
                        @if `activeMode == ACTIVE_SEL_TAG_HAND ||
                             activeMode == ACTIVE_SEL_DIS_HAND bl {
                            _changeSceneState(SCENE_CHOICE_HAND)
                        //場のカードを選ぶ
                        } .elif `activeMode == ACTIVE_SEL_TAG_MONSTER ||
                                 activeMode == ACTIVE_SEL_DIS_MONSTER bl {
                            _changeSceneState(SCENE_CHOICE_FIELD)
                        //確認する
                        } .else bl {
                            _changeSceneState(SCENE_CONFIRM)
                        }
                    }

                //カードの選択位置を動かす
                } .elif `!((iptHCounter - 1) % INPUT_REPEAT) bl {
                    bitOn(triggerFlg, TR_CHG_CURSOR)
                    bitOn(triggerFlg, TR_SE_CURSOR)
                    //選択位置を変える
                    activeIdx = (activeIdx + iptH + handNum) % handNum
                    //選択しているカードの種類
                    readFromArray(activeType, handArr, activeIdx)
                    //短い説明文を表示する
                    _showShortExplan(activeType)
                }

            //----------------------------
            //発動するか確認する
            } .elif sceneState == SCENE_CONFIRM bl {
                //最初のフレーム
                @if sceneTimer == 0 bl {
                    //字幕表示
                    _showAboveExplan(activeMode)
                    _showLongExplan(activeType)
                }

                //発動/捨てる
                @if `CHK_DECISION bl {
                    _changeSceneState(SCENE_ACTIVE)
                //戻る
                //横入力でもキャンセルできる
                } .elif `CHK_CANCEL || iptHCounter != 0 bl {
                    bitOn(triggerFlg, TR_SE_CANCEL)
                    _changeSceneState(SCENE_CHOICE_ACTIVATE)
                }

            //----------------------------
            //場からカードを選択する / 手札からカードを選択する
            } .elif `sceneState == SCENE_CHOICE_FIELD ||
                     sceneState == SCENE_CHOICE_HAND bl {
                //最初のフレーム
                @if sceneTimer == 0 bl {
                    bitOn(triggerFlg, TR_CHG_CURSOR)
                    //選択状態を初期化する
                    chooseReq   = $CHOOSE_NUM
                    chooseNum   = 0
                    chooseIdx   = 0
                    chooseBit   = 0
                    chooseType  = 0
                    chooseLevel = 0
                    chooseFirst = 0
                    //場
                    @if sceneState == SCENE_CHOICE_FIELD bl {
                        //左端のカードにカーソルを合わせる
                        chooseIdx = 0
                    //手札
                    } .elif sceneState == SCENE_CHOICE_HAND bl {
                        //発動中のカードに合わせる
                        chooseIdx = activeIdx
                    }
                    //字幕表示
                    _showAboveExplan(activeMode)
                    _showLongExplan(activeType)
                }

                //決定
                @if `CHK_DECISION bl {
                    bitOn(triggerFlg, TR_CHG_CURSOR)
                    //選択の可否を判定する為の変数
                    //場
                    @if sceneState == SCENE_CHOICE_FIELD bl {
                        readFromArray(chooseType, fieldArr, chooseIdx)
                        _getMonsterLevel(chooseLevel, chooseType)//選択したカードのLV
                    //手札
                    } .else bl {
                        readFromArray(chooseType, handArr, chooseIdx)
                        chooseLevel = 0
                    }

                    //選択対象
                    //空白を選択していると無条件で選べない
                    //また、発動中のカードは選べない
                    @if `(sceneState == SCENE_CHOICE_FIELD && chooseType <= 0) ||
                         (sceneState == SCENE_CHOICE_HAND  && (chooseType == CARD_NONE || chooseIdx == activeIdx)) bl {
                        bitOn(triggerFlg, TR_SE_CANCEL)
                    } .else bl {
                        //カードの種類ごとに判断基準が異なる
                        flag = $CHOICE_CARD
                        //db_log(__str("f:\",flag, " t:\",chooseType, " a:\", activeType))
                        //選択不可
                        @if `!flag bl {
                            bitOn(triggerFlg, TR_SE_CANCEL)
                        //選択可能
                        } .else bl {
                            //ビットフラグ
                            cell = (1 << chooseIdx)
                            //選択解除
                            @if `chooseBit & cell bl {
                                bitOff(chooseBit, cell)

                                chooseNum -= 1
                                @if chooseNum <= 0 bl {
                                    chooseFirst = 0

                                }

                                bitOn(triggerFlg, TR_SE_CANCEL)

                            //選択する
                            } .else bl {
                                bitOn(chooseBit, cell)

                                chooseNum += 1
                                //最初に選択した魔物のLVを記録する
                                @if chooseNum == 1 bl {
                                    chooseFirst = chooseLevel

                                }

                                //規定数選択すると発動する
                                @if chooseNum >= chooseReq bl {
                                    _changeSceneState(SCENE_ACTIVE)

                                //対象が1枚増えた
                                } .else bl {
                                    bitOn(triggerFlg, TR_SE_DECISION)
                                }
                            }
                        }
                    }

                //キャンセルすると手札の選択に戻る
                } .elif `CHK_CANCEL bl {
                    bitOn(triggerFlg, TR_SE_CANCEL)
                    _changeSceneState(SCENE_CHOICE_ACTIVATE)

                //カードの選択位置を動かす
                } .elif `!((iptHCounter - 1) % INPUT_REPEAT) bl {
                    bitOn(triggerFlg, TR_CHG_CURSOR)
                    bitOn(triggerFlg, TR_SE_CURSOR)

                    //場
                    @if sceneState == SCENE_CHOICE_FIELD bl {
                        chooseIdx = (chooseIdx + iptH + FIELD_SIZE) % FIELD_SIZE
                    //手札
                    } .elif sceneState == SCENE_CHOICE_HAND bl {
                        chooseIdx = (chooseIdx + iptH + handNum) % handNum
                    }
                }

            //----------------------------
            //カードを発動する
            } .elif sceneState == SCENE_ACTIVE bl {
                //演出
                @if sceneTimer == 0 bl {
                    //効果音
                    @if activeMode == ACTIVE_DISPOSE bl {
                        bitOn(triggerFlg, TR_SE_DISPOSE)
                    } .else bl {
                        bitOn(triggerFlg, TR_SE_ACTIVE)
                    }

                    //字幕を非表示にする
                    _showAboveExplan(ACTIVE_NONE)
                    _showLongExplan(CARD_NONE)
                }

                //スタックにデータを積む
                @if sceneTimer == 8 bl {
                    //使用カード数増加
                    //捨てる時は加算されない
                    @if `activeMode != ACTIVE_DISPOSE bl {
                        usedScore += 1
                    }
                    //スタック初期化
                    _initStack()
                    //効果解決後、手札を捨てて詰める
                    //捨てる手札をビットフラグで指定する
                    //不発の場合はディレイがなくなる
                    eleA = (1 << activeIdx)
                    eleB = (activeMode == ACTIVE_DISPOSE) ? 0 : 8

                    _pushStack(STACK_PACK_HAND, 0, 8)
                    _pushStack(STACK_REMOVE_HAND, eleA, eleB)

                    //発動時の処理
                    @if activeMode != ACTIVE_DISPOSE bl {
                        //カードのごとに処理が異なる
                        __loop $ACTIVE_CARD $block $idx bl {
                            __if $idx > 0 bl {
                                @if activeType == $idx bl {
                                    $block
                                }
                            }
                        }
                    }

                    //スタックを崩す
                    _changeSceneState(SCENE_STACK)
                }

            //----------------------------
            //勝敗や手札の数をチェックする
            //スタックの処理を終えるごとにここに戻ってくる
            } .elif sceneState == SCENE_JUDGE bl {
                //手札の勇者の数を調べる
                //今では未使用の変数
                braveHandNum = 0
                @loop HAND_SIZE .dst(idxA) bl {
                    readFromArray(eleA, handArr, idxA)
                    @if eleA == CARD_BRAVE bl {
                        braveHandNum += 1
                    }
                }

                //魔物の数とLVをチェック
                fieldNum = 0
                availableUnion = FALSE
                maxFieldLevel = -1
                minFieldLevel = LEVEL_MAX + 1

                sx = 0//最大LVの魔物の数
                @loop FIELD_SIZE .dst(idxA) bl {
                    readFromArray(eleA, fieldArr, idxA)
                    _getMonsterLevel(eleA, eleA)

                    @if eleA > 0 bl {
                        fieldNum += 1

                        maxFieldLevel = max(maxFieldLevel, eleA)
                        minFieldLevel = min(minFieldLevel, eleA)

                        @if eleA >= LEVEL_MAX bl {
                            sx += 1
                        }
                    }

                    //合体を発動できるかどうか調べる
                    @if `!availableUnion bl {
                        //1 <= level <= max-1
                        @if `between(eleA, 1, LEVEL_MAX - 1) bl {
                            @loop FIELD_SIZE .dst(idxB) bl {
                                idxB += idxA + 1
                                @if idxB < FIELD_SIZE bl {
                                    readFromArray(eleB, fieldArr, idxB)
                                    _getMonsterLevel(eleB, eleB)
                                    @if eleA == eleB bl {
                                        availableUnion = TRUE
                                        @break
                                    }
                                }
                            }
                        }
                    }
                }

                dragonScore = max(dragonScore, sx)

                //場に魔物がいない場合、敗北
                @if fieldNum <= 0 bl {
                    //無敵モードの時は魔物を1体追加して続ける
                    //ただ、デッキが無いとどうしようもない
                    
                    @if `deckSize > 0 && invincibleSwitch bl {
                        _initStack()
                        _pushStack(STACK_ADD_MONSTER, 1, 0)
                        _changeSceneState(SCENE_STACK)

                    //敗北
                    } .else bl {
                        result = RESULT_LOSE
                        _changeSceneState(SCENE_RESULT)
                    }

                //特殊勝利
                } .elif `dragonScore >= FIELD_SIZE bl {
                    result = RESULT_SPECIAL
                    _changeSceneState(SCENE_RESULT)

                //通常勝利
                //ゲームモードによっては無視される
                } .elif `ClearConditions == CONDITIONS_NORMAL && dragonScore >= 1 bl {
                    result = RESULT_WIN
                    _changeSceneState(SCENE_RESULT)

                //手札もデッキも無い
                } .elif `deckNum <= 0 && handNum <= 0 bl {
                    //元のデッキ枚数がゼロになっているとゲームが続けられないので敗北扱いとする
                    @if deckSize <= 0 bl {
                        result = RESULT_LOSE
                        _changeSceneState(SCENE_RESULT)
                    } .else bl {
                        _changeSceneState(SCENE_DECK_BACK)
                    }

                //デッキが残っており、手札が規定枚数よりも少ない
                } .elif `deckNum > 0 && handNum < HAND_LIMIT bl {
                    //ドロー
                    idxA = HAND_LIMIT - handNum
                    _pushStack(STACK_DRAW, idxA, 0)
                    _changeSceneState(SCENE_STACK)

                } .else bl {
                    //手札の選択
                    _changeSceneState(SCENE_CHOICE_ACTIVATE)
                }

            //----------------------------
            //敗北/勝利/特殊勝利
            } .elif `sceneState == SCENE_RESULT bl {
                @if sceneTimer == 0 bl {
                    @wait(4)

                    //スコア計算
                    score = max(dragonScore * 1000 - round * 100 - usedScore * 1, 0)
                    //ハイスコアを更新する
                    _updateHighScore()
                    //実績
                    checkSetAchievement(achievedDragopy, result == RESULT_SPECIAL && deckType == DECK_CIVILWAR)
                    //一枚絵と効果音が変わる
                    //特殊勝利
                    @if result == RESULT_SPECIAL bl {
                        cell = 3
                        @scr.flash .once(4) .rgbv(31, 31, 31, 24)
                        @se.play "voice_ieeei2" .opt(80, 120, 50)
                        @se.play "cheers" .opt(100, 120, 50)

                    //通常
                    } .elif result == RESULT_WIN bl {
                        cell = 2
                        @se.play "Holy7" .opt(100, 100, 50)

                    //敗北
                    } .else bl {
                        cell = 1
                        @se.play "bell1" .opt(100, 50, 50)
                    }

                    //背景
                    @pic.show [PIC_EVENT_WINDOW] .pos(160, 100) .center .scale2(2000, 10) .trans(WINDOW_TRANS) windowPicCmd
                    @pic.move [PIC_EVENT_WINDOW] .relative .pos(0, 0) .scale2(2000, 700 - 10) .trans(0) .time(-8)
                    //一枚絵
                    @pic.show [PIC_RESULT] .pos(160, 96) .center .scale(100) .trans(100) .cell(cell) resultPicCmd
                    @pic.move [PIC_RESULT] .relative .pos(0, -8) .scale(0) .trans(-100) .time(-10)
                    //スコア
                    $TEXT = __str("\c[0]Dragon : \", dragonScore, NEWLINE,
                    " Round : \", round, NEWLINE,
                    "  Used : \", usedScore, NEWLINE,
                    "\c[2] Score : \", score )
                    @pic.strpic [PIC_EVENT_TEXT] $TEXT .pos(120, 96) .topLeft .trans(0) boldStrPicCmd
                    @pic.move [PIC_EVENT_TEXT] .relative .pos(0, -8) .scale(0) .trans(-100) .time(-10)
                }

                @if sceneTimer == 80 bl {
                    //通常勝利の場合はクリア条件を変えて続けられる
                    @if result == RESULT_WIN bl {
                        @msg.choice bl {
                            .cancel(3)
                            .case "\>\c[2]ドラゴン４体を目指す\c[0]" {
                                //ピクチャを片付ける
                                hidePicturesForEach( [ PIC_EVENT_WINDOW, PIC_EVENT_TEXT, PIC_RESULT ] )
                                //ゲームモードを変更して続行する
                                ClearConditions = CONDITIONS_FULL
                                _changeSceneState(SCENE_JUDGE)
                            }
                            .case "\>\c[2]デッキを変える\c[0]" {
                                deckType = DECK_NONE
                                @label.jump "gameLoop"
                            }
                            .case "\>やりなおす" {
                                @label.jump "gameLoop"
                            }
                            .case "\>やめる" {
                                @label.jump "gameEnd"
                            }
                        }
                    } .else bl {
                        @msg.choice bl {
                            .cancel(2)
                            .case "\>やりなおす" {
                                @label.jump "gameLoop"
                            }
                            .case "\>\c[2]デッキを変える\c[0]" {
                                deckType = DECK_NONE
                                @label.jump "gameLoop"
                            }
                            .case "\>やめる" {
                                @label.jump "gameEnd"
                            }
                        }
                    }
                }

            //----------------------------
            //デッキを戻してシャッフルする
            } .elif sceneState == SCENE_DECK_BACK bl {
                $CHK_INSERT_BRAVE = (round <= BRAVE_MAX && deckSize < DECK_SIZE)

                //最初のフレーム
                @if sceneTimer == 0 bl {
                    //間を調節する為に変数を書き換えるのがめんどくさい
                    @wait(2)
                    @se.play "Magic1" .opt(80, 100, 50)

                    idxA = round + 1
                    @pic.strpic [PIC_EVENT_TEXT] __str("\c[7]Round \", idxA) .pos(EVENT_CENTER_X, EVENT_CENTER_Y - 40) .center .trans(100) boldStrPicCmd
                    @pic.move [PIC_EVENT_TEXT] .relative .pos(0, -8) .scale(0) .trans(-100) .time(-8)

                    @pic.show [PIC_EVENT_WINDOW] .pos(EVENT_CENTER_X, EVENT_CENTER_Y) .center .scale2(2000, 10) .trans(WINDOW_TRANS) windowPicCmd
                    @pic.move [PIC_EVENT_WINDOW] .relative .pos(0, 0) .scale2(2000, 700 - 10) .trans(0) .time(-8)

                    @pic.show [PIC_EVENT_CARD + 1] .pos(EVENT_CENTER_X, EVENT_CENTER_Y + 8) .center .trans(100) .cell(DECK_CELL) .angle(-10. 1) cardPicCmd
                    @pic.move [PIC_EVENT_CARD + 1] .relative .pos(0, -8) .scale(0) .trans(-100) .time(-8) .angle(-10. 1)

                    //デッキのピクチャを非表示にする
                    @pic.move [PIC_DECK] .pos(OUT_RANGE, OUT_RANGE) .trans(100)

                    //字幕を非表示にする
                    _showShortExplan(CARD_NONE)
                    _showAboveExplan(ACTIVE_NONE)
                }

                //勇者を追加する
                @if `between(sceneTimer, 12, 12 + 20 + 6 + 6) bl {
                    @if sceneTimer == 12 bl {
                        //ラウンドが範囲内で、デッキサイズに余裕がある
                        @if `$CHK_INSERT_BRAVE bl {
                            @pic.show [PIC_EVENT_CARD + 0] .pos(EVENT_CENTER_X + 96, EVENT_CENTER_Y) .center .trans(50) .cell(BRAVE_CELL) cardPicCmd
                            @pic.move [PIC_EVENT_CARD + 0] .relative .pos(-24, 0) .scale(0) .trans(-50) .time(-8)

                            bitOn(triggerFlg, TR_SE_CURSOR)

                        //勇者を追加するアニメーションを省略する
                        } .else bl {
                            sceneTimer = 52 - 1
                        }
                    }

                    @if sceneTimer == 12 + 20 bl {
                        @pic.move [PIC_EVENT_CARD + 0] .relative .pos(0, 0) .scale2(-100, 0) .trans(0) .time(-6)
                    }

                    @if sceneTimer == 12 + 20 + 6 bl {
                        @pic.show [PIC_EVENT_CARD + 0] .pos(EVENT_CENTER_X + 96 - 24, EVENT_CENTER_Y) .center .scale2(0, 100) .cell(DECK_CELL) cardPicCmd
                        @pic.move [PIC_EVENT_CARD + 0] .relative .pos(0, 0) .scale2(100, 0) .trans(0) .time(-6)
                    }

                    @if sceneTimer == 12 + 20 + 6 + 6 bl {
                        @pic.move [PIC_EVENT_CARD + 0] .relative .pos(-(96 - 24), 0) .scale(0) .trans(0) .angle(-10. 1) .time(-6)
                    }
                }

                //シャッフル
                @if `between(sceneTimer, 52, 52 + 12 * 3 - 1) bl {
                    idxA = (sceneTimer - 52) % 12

                    @if idxA == 0 bl {
                        @pic.show [PIC_EVENT_CARD + 1] .pos(EVENT_CENTER_X, EVENT_CENTER_Y) .center .trans(0) .cell(DECK_CELL) .angle(-10. 1) cardPicCmd
                        @pic.move [PIC_EVENT_CARD + 1] .relative .pos( -6, -30) .scale(0) .trans(0) .time(-4) .angle(-10. 1)

                        @pic.show [PIC_EVENT_CARD + 0] .pos(EVENT_CENTER_X, EVENT_CENTER_Y) .center .trans(0) .cell(DECK_CELL) .angle(-10. 1) cardPicCmd
                        @pic.move [PIC_EVENT_CARD + 0] .relative .pos( 10, 50) .scale(0) .trans(0) .time(-4) .angle(-10. 1)
                    }

                    @if idxA == 4 bl {
                        @pic.show [PIC_EVENT_CARD + 1] .pos(EVENT_CENTER_X + 10, EVENT_CENTER_Y + 50) .center .trans(0) .cell(DECK_CELL) .angle(-10. 1) cardPicCmd
                        @pic.move [PIC_EVENT_CARD + 1] .relative .pos(-10, -50) .scale(0) .trans(0) .time(-8) .angle(-10. 1)

                        @pic.show [PIC_EVENT_CARD + 0] .pos(EVENT_CENTER_X - 6, EVENT_CENTER_Y - 30) .center .trans(0) .cell(DECK_CELL) .angle(-10. 1) cardPicCmd
                        @pic.move [PIC_EVENT_CARD + 0] .relative .pos( 6, 30) .scale(0) .trans(0) .time(-8) .angle(-10. 1)
                    }
                }

                //デッキを戻して背景を消す
                @if `between(sceneTimer, 100, 100 + 8) bl {
                    @if sceneTimer == 100 bl {
                        @pic.show [PIC_EVENT_CARD + 1] .pos(EVENT_CENTER_X, EVENT_CENTER_Y) .center .cell(DECK_CELL) .angle(-10. 1) cardPicCmd
                        @pic.move [PIC_EVENT_CARD + 1] .pos(DECK_X, DECK_Y) .center .angle(0, 1) .time(-8)

                        @pic.move [PIC_EVENT_CARD + 0] .pos(OUT_RANGE, OUT_RANGE) .trans(100)

                        @pic.move [PIC_EVENT_WINDOW] .relative .pos(0, 0) .center .scale2(0, -700) .trans(0) .time(-8)
                        @pic.move [PIC_EVENT_TEXT] .relative .pos(0, 32) .center .scale(0) .trans(100) .time(-8)
                    }

                    @if sceneTimer == 100 + 8 bl {
                        @pic.move [PIC_EVENT_CARD + 1] .pos(OUT_RANGE, OUT_RANGE) .trans(100)

                        @pic.move [PIC_EVENT_WINDOW] .pos(OUT_RANGE, OUT_RANGE) .trans(100)
                        @pic.move [PIC_EVENT_TEXT] .pos(OUT_RANGE, OUT_RANGE) .trans(100)

                        //デッキのピクチャを戻す
                        @pic.show [PIC_DECK] .pos(DECK_X, DECK_Y) .center .cell(DECK_CELL) cardPicCmd
                    }
                }

                //内部処理を行い、ドローに移る
                @if sceneTimer == 108 bl {
                    //ドロー
                    _pushStack(STACK_DRAW, HAND_LIMIT, 0)
                    //デッキシャッフル
                    _pushStack(STACK_SHUFFLE_DECK, 0, 0)
                    //デッキを戻す
                    _pushStack(STACK_BACK_DECK, 0, 0)
                    //デッキに勇者を追加する
                    @if `$CHK_INSERT_BRAVE bl {
                        _pushStack(STACK_ADD_DECK, CARD_BRAVE, 0)
                    }

                    //次ラウンド
                    round += 1

                    _setStackState(STACK_POP, 0, 0)
                    _changeSceneState(SCENE_STACK)
                }

            //----------------------------
            //スタックに積まれた処理を行う
            } .elif sceneState == SCENE_STACK bl {
                //スタックからデータを取得する
                @if stackState == STACK_POP bl {
                    //タイマー初期化
                    stackTimer = -1
                    @if stackNum > 0 bl {
                        //スタックフローをチェック
                        @if `!between(stackNum, 0, STACK_SIZE) bl {
                            __str("Error: スタックのデータ数が範囲外の値です : \", stackNum)
                            @label.jump "gameEnd"
                        }
                        //スタック処理の状態を変える
                        _popStack(stackState, stackParam, stackDelay)
                        //db_log(__str("\",stackState, ",\",stackParam, ",\",stackDelay))
                    }
                }

                //ディレイ
                @if stackDelay > 0 bl {
                    stackDelay -= 1

                //スタックにデータが無い場合、勝敗判定を行う
                } .elif stackState == STACK_POP bl {
                    _changeSceneState(SCENE_JUDGE)

                //スタックマシンの状態に応じた処理
                } .else bl {
                    //タイマー
                    stackTimer += 1

                    //----------------------------
                    //デッキにカードを追加する
                    //parama : 追加するカードの種類
                    @if stackState == STACK_ADD_DECK bl {
                        //空いている所に入れる
                        idxB = -1
                        @loop DECK_SIZE .dst(idxA) bl {
                            readFromArray(eleA, deckArr, idxA)
                            @if eleA == CARD_NONE bl {
                                idxB = idxA
                                @break
                            }
                        }

                        @if idxB >= 0 bl {
                            writeToArray(stackParam, deckArr, idxA)
                            deckSize += 1
                        }

                        //次の処理へ
                        _setStackState(STACK_POP, 0, 0)

                    //----------------------------
                    //捨て札をデッキに戻す
                    //デッキ枚数をカウントしなおす
                    } .elif stackState == STACK_BACK_DECK bl {
                        //デッキのカードを降順に並べる
                        //空きを詰める為
                        deckArr.sortDescending(DECK_SIZE - 1)

                        //デッキ枚数を数える
                        deckSize = 0
                        @loop DECK_SIZE .dst(idxA) bl {
                            readFromArray(eleA, deckArr, idxA)
                            @if eleA != CARD_NONE bl {
                                deckSize += 1
                            }
                        }
                        //残りのデッキ枚数
                        deckNum = deckSize
                        //次の処理へ
                        _setStackState(STACK_POP, 0, 0)
                        
                    //----------------------------
                    //デッキをシャッフルする
                    } .elif stackState == STACK_SHUFFLE_DECK bl {

                        idxA = __id(deckArr) + (deckSize - deckNum)//始点
                        
                        //最初に降順に並べる
                        idxB = deckNum
                        v[idxA].sortDescending(idxB)
                        //シャッフルの範囲は1つだけ多めにとる
                        idxB = deckNum + 1
                        v[idxA].shuffle(idxB)
                        //次の処理へ
                        _setStackState(STACK_POP, 0, 0)

                    //----------------------------
                    //捨て札の中から指定したカードを取り除く
                    //デッキ枚数は変わらないので、山札を戻す際に数え直す必要がある
                    //param : カードの種類
                    } .elif stackState == STACK_REMOVE_DISPOSE bl {

                        //取り除くカードの種類
                        eleB = stackParam
                        @loop DECK_SIZE .dst(idxA) bl {
                            //deckSize - deckNum = 次にドローするカードの位置
                            @if `deckSize - deckNum <= idxA bl {
                                @break
                            }

                            readFromArray(eleA, deckArr, idxA)

                            //空白に差し替える
                            @if eleA == eleB bl {
                                writeToArray(CARD_NONE, deckArr, idxA)
                                //取り除くのは1枚だけ
                                @break
                            }
                        }
                        //次の処理へ
                        _setStackState(STACK_POP, 0, 0)

                    //----------------------------
                    //捨て札の中から「魅了」のカードを指定したカードにすり替える
                    //param : カードの種類
                    } .elif stackState == STACK_REPLACE_CHARM bl {
                        //入れるカードの種類
                        eleB = stackParam
                        @loop DECK_SIZE .dst(idxA) bl {
                            //deckSize - deckNum = 次にドローするカードの位置
                            @if `deckSize - deckNum <= idxA bl {
                                @break
                            }

                            readFromArray(eleA, deckArr, idxA)

                            //「魅了」を他のカードに差し替える
                            @if eleA == CARD_CHARM bl {
                                writeToArray(eleB, deckArr, idxA)
                                //すり替えるのは1枚だけ
                                @break
                            }
                        }
                        
                        //次の処理へ
                        _setStackState(STACK_POP, 0, 0)

                    //----------------------------
                    //デッキから指定枚数ドローする
                    } .elif stackState == STACK_DRAW bl {
                        $MOVE_TIME = 8
                        //1枚ドロー
                        @if `!(stackTimer % $MOVE_TIME) bl {
                            //成功フラグ
                            flag = FALSE
                            //残りドロー枚数と残りデッキ枚数がある
                            @if `stackParam > 0 && deckNum > 0 bl {
                                //手札の空きを探す
                                idxB = -1
                                @loop HAND_SIZE .dst(idxA) bl {
                                    readFromArray(eleA, handArr, idxA)
                                    @if eleA == CARD_NONE bl {
                                        idxB = idxA
                                        @break
                                    }
                                }

                                //空きがあった
                                @if idxB >= 0 bl {
                                    //デッキの一番下を手札の空きにコピーする
                                    idxA = deckSize - deckNum
                                    readFromArray(eleB, deckArr, idxA)
                                    writeToArray(eleB, handArr, idxB)

                                    //デッキ枚数を減らし、手札枚数を増やす
                                    deckNum -= 1
                                    handNum += 1

                                    //ピクチャを移動させる
                                    _getHandPicture(pid, idxB)
                                    _getHandCell(cell, eleB)
                                    @pic.show [pid] .pos(DECK_X, DECK_Y) .center .cell(cell) cardPicCmd

                                    //他のカードも寄せる
                                    @loop HAND_SIZE .dst(idxA) bl {
                                        readFromArray(eleA, handArr, idxA)
                                        @if eleA != CARD_NONE bl {
                                            _V2_getHandPosition(sx, idxA)
                                            _getHandPicture(pid, idxA)
                                            _getHandCell(cell, eleA)
                                            @pic.move [pid] .pos(sx, sy) .center .time(-$MOVE_TIME)
                                        }
                                    }

                                    //デッキ枚数を更新する
                                    @if deckNum > 0 bl {
                                        @pic.strpic [PIC_DECK_COUNTER] __str("\c[7]\", deckNum,"枚") .pos(DECK_X, DECK_Y + 48) .center boldStrPicCmd
                                        @pic.show [PIC_DECK] .pos(DECK_X, DECK_Y) .center .cell(DECK_CELL) cardPicCmd

                                    //デッキが切れた
                                    } .else bl {
                                        @pic.move [PIC_DECK_COUNTER] .pos(OUT_RANGE, OUT_RANGE) .center .trans(100)
                                        @pic.move [PIC_DECK] .pos(OUT_RANGE, OUT_RANGE) .center .trans(100)
                                    }

                                    bitOn(triggerFlg, TR_SE_CURSOR)

                                    //ドロー成功
                                    stackParam -= 1
                                    flag = TRUE
                                }
                            }

                            //ドローできなければ、そこで終了する
                            @if `!flag bl {
                                //次の処理へ
                                _setStackState(STACK_POP, 0, 0)
                            }
                        }

                    //----------------------------
                    //手札の空白を詰める
                    } .elif stackState == STACK_PACK_HAND bl {
                        $MOVE_TIME = 8

                        @loop HAND_SIZE .dst(idxA) bl {
                            //詰めるべき空白を見つける
                            readFromArray(eleA, handArr, idxA)
                            @if eleA == CARD_NONE bl {
                                //さらに調べて、詰めるべき要素を見つける
                                @loop HAND_SIZE .dst(idxB) bl {
                                    idxB += idxA + 1
                                    //最後まで見つからなかった場合は反復処理を打ち切る
                                    @if idxB >= HAND_SIZE bl {
                                        @break(2)
                                    }

                                    //空白はスルーする
                                    readFromArray(eleB, handArr, idxB)
                                    @if eleB == CARD_NONE bl {
                                        @continue
                                    }

                                    //__str("[\", idxA, "] = \", eleB, " [\",idxB, "] = \",eleA)

                                    //要素を入れ替える
                                    writeToArray(eleB, handArr, idxA)
                                    writeToArray(eleA, handArr, idxB)

                                    //Bのピクチャの位置を記憶する
                                    _getHandPicture(pid, idxB)
                                    @pic.getInfo [pid] .currentRect(sx, sy, 0, 0) .cewh
                                    //Bのピクチャを非表示にする
                                    @pic.move [pid] .pos(OUT_RANGE, OUT_RANGE) .center .trans(100)
                                    //AのピクチャをBのピクチャの位置から動かす
                                    _V2_getHandPosition(ex, idxA)
                                    _getHandPicture(pid, idxA)
                                    _getHandCell(cell, eleB)
                                    @pic.show [pid] .pos(sx, sy) .center .cell(cell) cardPicCmd
                                    @pic.move [pid] .pos(ex, ey) .center .time(-$MOVE_TIME)

                                    @break
                                }
                            }
                        }

                        //次の処理へ
                        _setStackState(STACK_POP, 0, 0)

                    //----------------------------
                    //指定されたカードを手札に加える
                    //param : 追加するカード
                    } .elif stackState == STACK_ADD_HAND bl {
                        $MOVE_TIME = 8
                        //追加するカード
                        eleB = stackParam
                        //手札の空きを探す
                        idxB = -1
                        @loop HAND_SIZE .dst(idxA) bl {
                            readFromArray(eleA, handArr, idxA)
                            @if eleA == CARD_NONE bl {
                                idxB = idxA
                                @break
                            }
                        }

                        @if idxB >= 0 bl {
                            //手札を加える
                            writeToArray(eleB, handArr, idxB)
                            handNum += 1
                            //ピクチャを用意する
                            _getHandPicture(pid, idxB)
                            _getHandCell(cell, eleB)
                            @pic.show [pid] .pos(DISPOSE_X, DISPOSE_Y) .center .cell(cell) cardPicCmd
                            //他のカードも寄せる
                            @loop HAND_SIZE .dst(idxA) bl {
                                readFromArray(eleA, handArr, idxA)
                                @if eleA != CARD_NONE bl {
                                    _V2_getHandPosition(sx, idxA)
                                    _getHandPicture(pid, idxA)
                                    _getHandCell(cell, eleA)
                                    @pic.move [pid] .pos(sx, sy) .center .time(-$MOVE_TIME)
                                }
                            }
                        }

                        //次の処理へ
                        _setStackState(STACK_POP, 0, 0)

                    //----------------------------
                    //指定された場所にいる手札を取り除く
                    //後で詰める必要がある
                    //param : 手札の位置(ビットフラグ)
                    } .elif stackState == STACK_REMOVE_HAND bl {
                        $MOVE_TIME = 8
                        @loop HAND_SIZE .dst(idxA) bl {
                            readFromArray(eleA, handArr, idxA)
                            //空きではなく、ビットフラグが立っている
                            @if `eleA > 0 && ((1 << idxA) & stackParam) bl {
                                //手札を取り除く
                                writeToArray(0, handArr, idxA)
                                handNum -= 1
                                //ピクチャを透かしながら移動させる
                                _getHandPicture(pid, idxA)
                                @pic.move [pid] .pos(DISPOSE_X, DISPOSE_Y) .center .trans(100) .time(-$MOVE_TIME)

                                bitOn(triggerFlg, TR_SE_CURSOR)
                            }
                        }
                        
                        //次の処理へ
                        _setStackState(STACK_POP, 0, 0)

                    //----------------------------
                    //空いている場に魔物を追加する
                    //param : 追加する魔物の番号
                    } .elif stackState == STACK_ADD_MONSTER bl {
                        $MOVE_TIME = 8
                        //追加する魔物
                        eleB = stackParam
                        //空いている場を探す
                        idxB = -1
                        @loop FIELD_SIZE .dst(idxA) bl {
                            readFromArray(eleA, fieldArr, idxA)
                            @if eleA <= 0 bl {
                                idxB = idxA
                                @break
                            }
                        }

                        //空きがあった and パラメータが正常
                        @if `idxB >= 0 && eleB >= 0 bl {
                            //魔物を置く
                            writeToArray(eleB, fieldArr, idxB)
                            fieldNum += 1
                            //ピクチャを移動させる
                            _V2_getMonsterPosition(ex, idxB)
                            _getMonsterPicture(pid, idxB)
                            _getMonsterCell(cell, eleB)
                            @pic.show [pid] .pos(DISPOSE_X, DISPOSE_Y) .center .cell(cell) cardPicCmd
                            @pic.move [pid] .pos(ex, ey) .center .time(-$MOVE_TIME)

                            bitOn(triggerFlg, TR_SE_CURSOR)
                        }

                        //次の処理へ
                        _setStackState(STACK_POP, 0, 0)

                    //----------------------------
                    //指定された場所にいる魔物を取り除く
                    //param : 魔物の位置(ビットフラグ)
                    } .elif stackState == STACK_REMOVE_MONSTER bl {
                        $MOVE_TIME = 8
                        @loop FIELD_SIZE .dst(idxA) bl {
                            readFromArray(eleA, fieldArr, idxA)
                            //空きではなく、ビットフラグが立っている
                            @if `eleA > 0 && ((1 << idxA) & stackParam) bl {
                                //魔物を取り除く
                                writeToArray(0, fieldArr, idxA)
                                fieldNum -= 1
                                //ピクチャを透かしながら移動させる
                                _getMonsterPicture(pid, idxA)
                                @pic.move [pid] .pos(DISPOSE_X, DISPOSE_Y) .center .trans(100) .time(-$MOVE_TIME)

                                bitOn(triggerFlg, TR_SE_CURSOR)
                            }
                        }

                        //次の処理へ
                        _setStackState(STACK_POP, 0, 0)

                    //----------------------------
                    //例外処理
                    } .else bl {
                        __str("Error: スタックのデータの値が不正です : \", stackState)
                        @label.jump "gameEnd"
                    }
                }
            }
            //----------------------------
            //トリガー
            @if `triggerFlg bl {
                //カードの短い説明文を表示する
                @if `(triggerFlg & TR_TEXT_SMALL) ||
                     (triggerFlg & TR_TEXT_NORMAL) bl {
                    //文字列変数を使用する
                    strLine .asg("")
                    //場合分けとピクチャ表示
                    __fn _switch_assignText $arr $height bl {
                        __loop $arr $str $idx bl {
                            __if $idx > 0 bl {
                                @if explanType == $idx bl {
                                    strLine .asg($str)
                                }
                            }
                        }

                        @pic.move [PIC_EXPLAN_WINDOW] .pos(320 / 2, 240 - $height / 2) .center .scale2(320 * 100 / 16, $height * 100 / 16) .trans(WINDOW_TRANS) .keepBlend
                        @pic.strpic [PIC_EXPLAN_TEXT] strLine .pos(0 + TEXT_MARGIN, 240 - $height + TEXT_MARGIN) .topLeft .size(320, $height) normalStrPicCmd
                    }

                    //空白を指定すると消える
                    @if explanType == CARD_NONE bl {
                        @pic.move [PIC_EXPLAN_WINDOW] .pos(OUT_RANGE, OUT_RANGE) .scale(100) .trans(100) .keepBlend
                        @pic.move [PIC_EXPLAN_TEXT] .pos(OUT_RANGE, OUT_RANGE) .scale(100) .trans(100)

                    //短い
                    } .elif `triggerFlg & TR_TEXT_SMALL bl {
                        _switch_assignText($SHORT_TEXTS, 24)

                    //通常
                    } .elif `triggerFlg & TR_TEXT_NORMAL bl {
                        _switch_assignText($LONG_TEXTS, 80)
                    }

                    //フラグOFF
                    bitOff(triggerFlg, TR_TEXT_SMALL | TR_TEXT_NORMAL)
                }

                //上に字幕を表示する
                @if `triggerFlg & TR_TEXT_ABOVE bl {
                    bitOff(triggerFlg, TR_TEXT_ABOVE)

                    strLine .asg("")

                    __loop $ABOVE_TEXTS $block $idx bl {
                        __if $idx > 0 bl {
                            @if aboveType == $idx bl {
                                strLine .asg($block .extract)
                            }
                        }
                    }

                    //空白の場合は非表示にする
                    @if aboveType <= 0 bl {
                        @pic.move [PIC_ABOVE_WINDOW] .pos(OUT_RANGE, OUT_RANGE) .scale(100) .trans(100) .keepBlend
                        @pic.move [PIC_ABOVE_TEXT] .pos(OUT_RANGE, OUT_RANGE) .scale(100) .trans(100)

                    } .else bl {
                        @pic.move [PIC_ABOVE_WINDOW] .pos(160, 12) .center .scale2(320 * 100 / 16, 24 * 100 / 16) .trans(WINDOW_TRANS) .keepBlend
                        @pic.strpic [PIC_ABOVE_TEXT] strLine .pos(160, 12) .center normalStrPicCmd
                    }
                }

                //選択状態を表示する
                @if `triggerFlg & TR_CHG_CURSOR bl {
                    bitOff(triggerFlg, TR_CHG_CURSOR)

                    //シーン状態によって処理が変わる
                    //手札
                    @loop HAND_SIZE .dst(idxA) bl {
                        readFromArray(eleA, handArr, idxA)
                        @if eleA != CARD_NONE bl {
                            _V2_getHandPosition(ex, idxA)
                            _getHandPicture(pid, idxA)
                            _getHandCell(cell, eleA)

                            //発動するカードを選択する
                            @if sceneState == SCENE_CHOICE_ACTIVATE bl {
                                //選択されているカードを少し上にあげる
                                @if idxA == activeIdx bl {
                                    ey -= 20
                                }

                                @pic.move[pid] .pos(ex, ey) .time(-4)

                            //効果の対象となる手札を選択する
                            } .elif sceneState == SCENE_CHOICE_HAND bl {
                                //選択されているカードを暗くして少し上にあげる
                                @if idxA == activeIdx bl {
                                    $FLUSH_STR = 50
                                    ey -= 28
                                    @pic.move[pid] .pos(ex, ey) .rgbs($FLUSH_STR, $FLUSH_STR, $FLUSH_STR, 100) .time(-4)

                                //対象として選択されたカードを少し上にあげる
                                } .elif `chooseBit & (1 << idxA) bl {
                                    ey -= 28
                                    @pic.move[pid] .pos(ex, ey) .time(-4)

                                //選択されたカードを少し上にあげる
                                } .elif idxA == chooseIdx bl {
                                    ey -= 20
                                    @pic.move[pid] .pos(ex, ey) .time(-4)

                                //それ以外
                                } .else bl {
                                    @pic.move[pid] .pos(ex, ey) .time(-4)
                                }


                            //効果の対象となる手札を選択する
                            } .elif sceneState == SCENE_CHOICE_FIELD bl {
                                //選択されているカードを暗くして少し上にあげる
                                @if idxA == activeIdx bl {
                                    ey -= 28
                                    @pic.move[pid] .pos(ex, ey) .time(-4)
                                }

                            //通常
                            } .else bl {
                                @pic.move[pid] .pos(ex, ey) .time(-4)
                            }
                        }
                    }

                    //場
                    @loop FIELD_SIZE .dst(idxA) bl {
                        readFromArray(eleA, fieldArr, idxA)
                        @if eleA > 0 bl {
                            _V2_getMonsterPosition(ex, idxA)
                            _getMonsterPicture(pid, idxA)
                            _getMonsterCell(cell, eleA)

                            //効果の対象となる魔物を選択する
                            @if sceneState == SCENE_CHOICE_FIELD bl {
                                //対象として選択されたカードを少し上にあげる
                                @if `chooseBit & (1 << idxA) bl {
                                    ey -= 20
                                    
                                //選択されたカードを少し上にあげる
                                } .elif idxA == chooseIdx bl {
                                    ey -= 8
                                }

                                @pic.move[pid] .pos(ex, ey) .time(-4)

                            //通常
                            } .else bl {
                                @pic.move[pid] .pos(ex, ey) .time(-4)
                            }
                        }
                    }

                    //カーソル
                    //効果の対象となる手札を選択
                    @if sceneState == SCENE_CHOICE_HAND bl {
                        _V2_getHandPosition(ex, chooseIdx)
                        ey -= 64 + 8
                        @pic.show [PIC_CURSOR] .pos(ex, ey) .center .cell(1) cursorPicCmd
                        @pic.move [PIC_CURSOR] .relative .pos(0, 8) .scale(0) .trans(0) .time(-4)

                    //効果の対象となる場のカードを選択
                    } .elif sceneState == SCENE_CHOICE_FIELD bl {
                        _V2_getMonsterPosition(ex, chooseIdx)
                        ey += 48 + 8
                        @pic.show [PIC_CURSOR] .pos(ex, ey) .center .cell(2) cursorPicCmd
                        @pic.move [PIC_CURSOR] .relative .pos(0,-8) .scale(0) .trans(0) .time(-4)

                    } .else bl {
                        @pic.move [PIC_CURSOR] .pos(OUT_RANGE, OUT_RANGE) .center .trans(100)
                    }
                }

                //効果音
                @if `triggerFlg & TR_SE_ACTIVE bl {
                    bitOff(triggerFlg, TR_SE_ACTIVE)
                    @se.play "Attack2" .opt(100, 100, 50)
                }

                @if `triggerFlg & TR_SE_DISPOSE bl {
                    bitOff(triggerFlg, TR_SE_DISPOSE)
                    @se.play "Bow2" .opt(100, 100, 50)
                }

                @if `triggerFlg & TR_SE_CURSOR bl {
                    bitOff(triggerFlg, TR_SE_CURSOR)
                    @se.play "page1" .opt(100, 150, 50)
                }

                @if `triggerFlg & TR_SE_DECISION bl {
                    bitOff(triggerFlg, TR_SE_DECISION)
                    @se.play "Cursor1" .opt(100, 120, 50)
                }

                @if `triggerFlg & TR_SE_CANCEL bl {
                    bitOff(triggerFlg, TR_SE_CANCEL)
                    @se.play "Buzzer3" .opt(100, 120, 50)
                }
            }
        }
    }

    //------------------------------------------------------------------------------------
    //終了する
    @label.set "gameEnd"
    bl {
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, TS_MINIGAME, NUM_OF_STR)
        fastFadeInTintOnly(1)
    }
}