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


cev[CEV_JANKEN_CARD] .name("mg_じゃんけんカード") {

    def {
        NUM_OF_VAR = 64
        NUM_OF_STR = 0
        NUM_OF_PIC = 24

        BASE_LAYER = 6

        PATH_CARD     = "jc\ca"
        PATH_DIAGRAM  = "jc\dg"
        PATH_RESULT   = "jc\re"
        PATH_BACK     = "jc\ba"

        PIC_HEAD      = 1
        PIC_BACK      = 2
        PIC_STAGE     = 3
        PIC_DIAGRAM   = 4
        PIC_EN_CARD   = 5//+0_+7
        PIC_MY_CARD   = 13//+0_+7
        PIC_RESULT    = 21
        PIC_DEBUG     = 22

        //定数
        STAGE_MAX = 12
        CARD_MAX = 8
        CARD_PATTERN = 5
        CARD_SPACE = 24
        MY_CARD_X = 172
        MY_CARD_Y = 206
        EN_CARD_X = 172
        EN_CARD_Y = 38
        MY_CENTER_X = 160 + 28 
        MY_CENTER_Y = 120 + 4
        EN_CENTER_X = 160 - 28
        EN_CENTER_Y = 120 - 4
        DIAGRAM_X = 234
        DIAGRAM_Y = 60
        RESULT_X = 160
        RESULT_Y = 112
        STAGE_NUMBER_X = 248
        STAGE_NUMBER_Y = 8

        //勝敗
        RESULT_NONE = 0
        RESULT_DRAW
        RESULT_WIN
        RESULT_LOSE
    }

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

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

        }

        cardPicCmd = {
            .center
            .mapLayer(BASE_LAYER)
            .grid(6, 1)
            basePicCmd
        }

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

    //変数定義
    defv {
        varHead = TV_MINIGAME

        ipt
        cou
        ele
        idx
        cell
        mpid
        epid
        ax
        ay

        result
        selectDir
        myWin
        enWin
        myCardNum
        enCardNum
        mySelected
        enSelected

        itCard0//初期手札
        itCard1
        itCard2
        itCard3
        itCard4
        itCard5
        itCard6
        itCard7
        myCard0//自分の手札
        myCard1
        myCard2
        myCard3
        myCard4
        myCard5
        myCard6
        myCard7
        enCard0//相手の手札
        enCard1
        enCard2
        enCard3
        enCard4
        enCard5
        enCard6
        enCard7

        varFoot
    }

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

    //カードの種類を取得
    __fn _getMyCardType $d $v {
        v[__id($d)] = v[__id(myCard0) + ($v)]
    }
    __fn _getEnemyCardType $d $v {
        v[__id($d)] = v[__id(enCard0) + ($v)]
    }

    //カードのピクチャ番号を取得する
    __fn _getMyCardPicture $d $v {
        v[__id($d)] = PIC_MY_CARD + ($v)
    }
    __fn _getEnemyCardPicture $d $v {
        v[__id($d)] = PIC_EN_CARD + ($v)
    }

    //------------------------------------------------------------------------------------
    //開始処理
    bl {
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, 0, 0)
        msgBottom()
        
        //初期手札
        //恐らく使わないが、念のために残す
        v[__id(itCard0)..__id(itCard0) + CARD_MAX - 1] = [1, 2, 4, 0, 0, 0, 0, 0]
        //ピクチャ
        @pic.show [PIC_RESULT] PATH_RESULT .pos(0, 0) .center .scale(100) .trans(100) .cell(1) resultPicCmd
        @pic.show [PIC_BACK] PATH_BACK .pos(0, 0) .topLeft .scale(100) .trans(0) basePicCmd
        @pic.show [PIC_DIAGRAM] PATH_DIAGRAM .pos(DIAGRAM_X, DIAGRAM_Y) .topLeft .scale(100) .trans(0) basePicCmd
        //暗転
        fastFadeInTintOnly(1)
        @wait(2)
        //ゲーム開始
        @label.jump "gameStart"
    }

    //------------------------------------------------------------------------------------
    //ゲーム処理
    @label.set "gameStart"
    bl {
        //変数を初期化する
        myWin = 0
        enWin = 0
        mySelected = 0
        enSelected = 0
        //カードを配る
        bl {
            //手札のパターンを決める
            //開始時、あるいは勝利した時に変える
            @if `result == RESULT_NONE || result == RESULT_WIN bl {
                //最初だけは勝利数と連動する
                @if jankenCardScore < STAGE_MAX bl {
                    idx = clamp(jankenCardScore, 0, STAGE_MAX - 1)
                //乱数で決める
                } .else bl {
                    idx = rnd(0, STAGE_MAX - 1)
                }
                //パターン番号を表示する
                cou = idx + 1
                @pic.strpic [PIC_STAGE] __str("STAGE: \", cou) .pos(STAGE_NUMBER_X, STAGE_NUMBER_Y) .topLeft .scale(100) .trans(0) numberStrPicCmd
                //初期手札
                __fn _case_setCards $num $arr {
                    @if idx == ($num) bl {
                        v[__id(itCard0)..__id(itCard0) + CARD_MAX - 1] = $arr
                    }
                }
                _case_setCards( 0, [1, 1, 2, 4, 0, 0, 0, 0] )//2,1,1
                _case_setCards( 1, [1, 2, 4, 4, 4, 0, 0, 0] )//4,1,1
                _case_setCards( 2, [1, 2, 2, 4, 4, 0, 0, 0] )//2,2,1
                _case_setCards( 3, [1, 1, 1, 2, 2, 4, 0, 0] )//3,2,1
                _case_setCards( 4, [1, 2, 4, 5, 0, 0, 0, 0] )//1,1,1,1
                _case_setCards( 5, [1, 2, 2, 4, 5, 5, 0, 0] )//1,2,2,1
                _case_setCards( 6, [1, 1, 2, 4, 5, 3, 0, 0] )//2,1,1,1,1
                _case_setCards( 7, [4, 5, 5, 3, 3, 0, 0, 0] )//2,2,1
                _case_setCards( 8, [1, 1, 1, 2, 2, 2, 4, 4] )//3,3,2
                _case_setCards( 9, [1, 1, 1, 2, 2, 2, 5, 0] )//3,3,1
                _case_setCards(10, [1, 4, 5, 3, 3, 3, 0, 0] )//1,1,1,3
                _case_setCards(11, [rnd(0, 5), rnd(0, 5), rnd(0, 5), rnd(0, 5), rnd(0, 5), 1, 2, 3] )//rnd

                //一周するとパターンをランダムで回転させるようになる
                @if jankenCardScore >= STAGE_MAX bl {
                    cou = rnd(0, CARD_PATTERN - 1)
                    @loop CARD_MAX .dst(idx) {
                        ele = __id(itCard0) + idx
                        @if `v[ele] > 0 bl {
                            v[ele] = 1 + (v[ele] - 1 + cou) % CARD_PATTERN
                        }
                    }
                }
            }

            //配列コピー
            v[__id(itCard0)].copy(v[__id(myCard0)], CARD_MAX)
            v[__id(itCard0)].copy(v[__id(enCard0)], CARD_MAX)
            //相手のカードはシャッフルする
            //シャッフルの範囲がおかしい？
            v[__id(enCard0)].shuffle(CARD_MAX + 1)
            //相手の手札を表示する
            //@pic.strpic [PIC_DEBUG] __str("\",enCard0, "\",enCard1, "\",enCard2, "\",enCard3, "\",enCard4, "\",enCard5, "\",enCard6, "\",enCard7,) .pos(0, 0) .topLeft
        }

        //カードの枚数を数える
        myCardNum = 0
        enCardNum = 0
        @loop CARD_MAX .dst(idx) {
            _getMyCardType(ele, idx)
            myCardNum += ele > 0 ? 1 : 0
            _getEnemyCardType(ele, idx)
            enCardNum += ele > 0 ? 1 : 0
        }

        //ピクチャを移動させる
        __fn _handOutCards $vid $pic $num $rev $x $y $time bl {
            cou = 0
            @loop CARD_MAX .dst(idx) {
                ele = v[$vid + idx]
                mpid = $pic + idx
                @if ele != 0 bl {
                    ax = $x - $num * CARD_SPACE / 2 + cou * CARD_SPACE
                    ay = $y

                    //表裏
                    __if $rev == TRUE bl { 
                        cell = ele + 1
                    } .else bl {
                        cell = 1
                    }

                    cou += 1

                    @pic.show[mpid] PATH_CARD .pos(280, $y) .scale(100) .trans(0) .cell(cell) cardPicCmd
                    @pic.move[mpid] .pos(ax, ay) .center .scale(100) .trans(0) .time(1)
                    @se.play "Switch2" .opt(80, 150, 50)
                    @wait .frame($time)

                } .else bl {
                    //表示しなくても用意しておく
                    @pic.show[mpid] PATH_CARD .pos(0, 0) .scale(100) .trans(100) .cell(1) cardPicCmd
                }
            }
        }

        _handOutCards(__id(myCard0), PIC_MY_CARD, myCardNum, TRUE,  MY_CARD_X, MY_CARD_Y, 5)
        _handOutCards(__id(enCard0), PIC_EN_CARD, enCardNum, FALSE, EN_CARD_X, EN_CARD_Y, 5)
        @wait(1)
        //カード選択へ
        @label.jump "cardSelection"
    }

    //------------------------------------------------------------------------------------
    //カードを選ぶ
    @label.set "cardSelection"
    bl {
        //----------------------------
        //相手はカードを選択する
        @se.play "Bow2" .opt(100, 100, 50)

        //ランダムに場所を選び、そこにカードが無いと番号をずらす
        enSelected = rnd(0, CARD_MAX - 1)
        @loop CARD_MAX bl {
            _getEnemyCardType(ele, enSelected)
            @if `ele > 0 bl {
                @break
            } .else bl {
                enSelected = (enSelected + 1) % CARD_MAX
            }
        }

        //選んだカードを前に出す
        _getEnemyCardPicture(epid, enSelected)
        @pic.move [epid] .pos(EN_CENTER_X, EN_CENTER_Y) .scale(100) .trans(0) .time(1)

        //それ以外のカードは整列
        cou = 0
        @loop CARD_MAX .dst(idx) {
            _getEnemyCardType(ele, idx)
            _getEnemyCardPicture(epid, idx)
            @if `ele > 0 && idx != enSelected bl {
                ax = EN_CARD_X - enCardNum * CARD_SPACE / 2 + cou * CARD_SPACE
                ay = EN_CARD_Y
                cou += 1
                @pic.move[epid] .pos(ax, ay) .scale(100) .trans(0) .rgbs(100, 100, 100, 100) .time(1)
            }
        }
        @wait(1)

        //----------------------------
        //自分のカードを選択する

        //選択位置の移動方向
        //カードが無い場合、その方向に選択位置がずれる
        selectDir = 1
        @loop bl {
            //選択位置をずらす
            @loop CARD_MAX bl {
                _getMyCardType(ele, mySelected)
                @if ele > 0 bl {
                    @break
                } .else bl {
                    mySelected = (mySelected + selectDir + CARD_MAX) % CARD_MAX
                }
            }

            //カードの整列
            cou = 0
            @loop CARD_MAX .dst(idx) {
                _getMyCardType(ele, idx)
                _getMyCardPicture(mpid, idx)
                @if ele > 0 bl {
                    ax = MY_CARD_X - myCardNum * CARD_SPACE / 2 + cou * CARD_SPACE
                    ay = MY_CARD_Y
                    cou += 1
                    //選択されている場合、光らせて前に出す
                    @if idx == mySelected bl {
                        ax -= 8
                        ay -= 20

                        @pic.move[mpid] .pos(ax, ay) .scale(100) .trans(0) .rgbs(200, 200, 200, 100)
                        @wait(0)
                        @pic.move[mpid] .relative .scale(0) .trans(0) .rgbs(100, 100, 100, 100) .time(2)

                    //選択されていない場合
                    } .else bl {
                        @pic.move[mpid] .pos(ax, ay) .scale(100) .trans(0) .rgbs(100, 100, 100, 100) .time(1)
                    }
                }
            }

            //カードが一枚しかない場合、自動で選択する
            @if myCardNum == 1 bl {
                @wait(1)
                @label.jump "disclosure"
            }

            //入力されるまで待つ
            @wait(0)
            getAnyKey(ipt, TRUE)
            //キャンセルキー:中断メニュー
            pauseProcces(FALSE, ipt, "gameEnd")
            //決定キー:カードを出す
            @if ipt == KEY_DECISION bl {
                @label.jump "disclosure"
            }
            //方向キー:カード選択
            ele = ((ipt == KEY_RIGHT || ipt == KEY_DOWN) ? 1 : 0) - ((ipt == KEY_LEFT || ipt == KEY_UP) ? 1 : 0)
            @if ele != 0 bl {
                selectDir = ele
                mySelected = (mySelected + ele + CARD_MAX) % CARD_MAX
                @se.play "Cursor2" .opt(70, 100, 50)
            }
        }
    }

    //------------------------------------------------------------------------------------
    //開示
    @label.set "disclosure"
    bl {
        //結果
        bl {
            _getMyCardType(mpid, mySelected)
            _getEnemyCardType(epid, enSelected)
            ele = ((epid - 1) - (mpid - 1) + CARD_PATTERN) % CARD_PATTERN
            //勝ち
            @if `between(ele, 1, 2) bl {
                result = RESULT_WIN
            //負け
            } .elif `between(ele, 3, 4) bl {
                result = RESULT_LOSE
            //あいこ or 例外
            } .else bl {
                result = RESULT_DRAW
            }
        }

        //ピクチャ番号
        _getMyCardPicture(mpid, mySelected)
        _getEnemyCardPicture(epid, enSelected)
        //自分のカードを場に出す
        @se.play "Bow2" .opt(100, 100, 50)
        @pic.move [mpid] .pos(MY_CENTER_X, MY_CENTER_Y) .scale(100) .trans(0) .time(1)
        @wait(2)

        //相手のカードをめくる
        @se.play "Ice3" .opt(100, 100, 50)
        _getEnemyCardType(cell, enSelected)
        cell += 1
        @pic.move[epid] .pos(EN_CENTER_X, EN_CENTER_Y) .scale2(0, 100) .trans(0) .time(1)
        @wait(1)
        @pic.show[epid] PATH_CARD .pos(EN_CENTER_X, EN_CENTER_Y) .scale2(0, 100) .trans(0) .cell(cell) cardPicCmd
        @pic.move[epid] .pos(EN_CENTER_X, EN_CENTER_Y) .center .scale2(100, 100) .trans(0) .time(1)
        @wait(5)

        //勝った方のカードが残り、端に置かれる
        @if result == RESULT_WIN bl {
            myWin += 1

            @se.play "Blow3" .opt(100, 100, 50)
            @pic.move[epid] .relative .pos(-160, -160) .center .scale(0) .trans(0) .time(1)
            @wait(1)
            @pic.move[epid] .pos(0, 0) .center .scale(0) .trans(100)
            
            @se.play "Chime2" .opt(100, 120, 50)
            ele = rnd(-20, 20)
            ax =  20 + (myWin - 1) / 2 * 24 + rnd(-2 ,2)
            ay = 216 - (myWin - 1) % 2 * 30 + rnd(-2 ,2)
            @pic.move[mpid] .pos(ax, ay) .center .scale(50) .trans(0) .angle(ele, 1) .time(1)

        } .elif result == RESULT_LOSE bl {
            enWin += 1

            @se.play "Blow4" .opt(100, 100, 50)
            @pic.move[mpid] .relative .pos(160, 160) .center .scale(0) .trans(0) .time(1)
            @wait(1)
            @pic.move[mpid] .pos(0, 0) .center .scale(0) .trans(100)

            @se.play "Buzzer1" .opt(100, 100, 50)
            ele = rnd(-20, 20)
            ax = 20 + (enWin - 1) / 2 * 24 + rnd(-2 ,2)
            ay = 22 + (enWin - 1) % 2 * 30 + rnd(-2 ,2)
            @pic.move[epid] .pos(ax, ay) .center .scale(50) .trans(0) .angle(ele, 1) .time(1)

        //あいこの場合は横に乱雑に置かれる
        } .elif result == RESULT_DRAW bl {
            @se.play "Evade1" .opt(100, 100, 50)

            ele = rnd(-180, 180)
            ax = 40 + rnd(-4, 4)
            ay = 120 - 10 + rnd(-4, 4)
            @pic.move[mpid] .pos(ax, ay) .center .scale(80) .trans(0) .angle(ele, 1) .time(1)

            ele = rnd(-180, 180)
            ax = 40 + rnd(-4, 4)
            ay = 120 + 10 + rnd(-4, 4)
            @pic.move[epid] .pos(ax, ay) .center .scale(80) .trans(0) .angle(ele, 1) .time(1)
        }

        //使用したカードはなくなる
        myCardNum -= 1
        enCardNum -= 1
        v[__id(myCard0) + mySelected] = 0
        v[__id(enCard0) + enSelected] = 0

        //カードが無くなったとき、判定に移る
        @if `myCardNum <= 0 || enCardNum <= 0 bl {
            @label.jump "judge"
        //もう一度
        } .else bl {
            @label.jump "cardSelection"
        }
    }

    //------------------------------------------------------------------------------------
    //勝敗判定
    @label.set "judge"
    bl {
        @wait(4)

        //勝利
        //無敵モードだと無条件で勝利する
        @if `myWin > enWin || invincibleSwitch bl {
            result = RESULT_WIN
            cell = 1
            @se.play "Holy7" .opt(100, 100, 50)

        //敗北
        } .elif myWin < enWin bl {
            result = RESULT_LOSE
            cell = 2
            @se.play "Collapse2" .opt(100, 100, 50)

        //引き分け or 例外
        } .else bl {
            result = RESULT_DRAW
            cell = 3
            @se.play "bell1" .opt(100, 80, 50)
        }

        //勝利数をカウント
        @if result == RESULT_WIN bl {
            jankenCardScore += 1
            checkSetAchievement(achievedJanken, jankenCardScore >= STAGE_MAX)
        }

        //帯
        @pic.show [PIC_RESULT] PATH_RESULT .pos(RESULT_X + 320, RESULT_Y) .center .scale(100) .trans(0) .cell(cell) resultPicCmd
        @wait(0)
        @pic.move [PIC_RESULT] .pos(RESULT_X, RESULT_Y) .center .scale(100) .trans(0) .time(2)
        @wait(10)

        //もう一回やる？
        replayProcess("replay", "gameEnd")
    }

    //------------------------------------------------------------------------------------
    //再開する
    @label.set "replay"
    bl {
        //帯を隠す
        @pic.move [PIC_RESULT] .pos(RESULT_X - 160, RESULT_Y) .center .scale(100) .trans(100) .time(2)
        //カードを下げる
        @loop CARD_MAX .dst(idx) bl {
            _getMyCardPicture(mpid, idx)
            _getEnemyCardPicture(epid, idx)

            @pic.move[mpid] .relative .pos(0, 200) .center .scale(0) .trans(0) .time(2)
            @pic.move[epid] .relative .pos(0, -200) .center .scale(0) .trans(0) .time(2)
        }

        @wait(4)
        @label.jump "gameStart"
    }

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