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


cev[CEV_MAMMOTH_GAME] .name("mg_マンモスゲーム") {

    def {
        NUM_OF_VAR = 64
        NUM_OF_STR = 0
        NUM_OF_PIC = 32

        BASE_LAYER = 6

        PATH_BASE     = "cm\da"
        PATH_MAMMOTH  = "mg\mo"
        PATH_FRIEND   = "mg\fr"
        PATH_OBSTRACT = "mg\ob"
        PATH_GROUND   = "mg\gr"
        PATH_SKY      = "mg\bg"
        PATH_COUNT    = "mg\co"
        PATH_TEXT     = "mg\te"

        PIC_HEAD     = 1
        PIC_BACK     = 2
        PIC_SKY      = 3//+0_+1
        PIC_GROUND   = 5//+0_+3
        PIC_FRIEND   = 9//+0_+3
        PIC_OBSTRACT = 13//+0_+1
        PIC_MAMMOTH  = 15
        PIC_SCORE    = 16//+0_+4
        PIC_HISCORE  = 21//+0_+4
        PIC_TEXT     = 26

        //実績
        ACHIEVE_SCORE = 4000

        //シーン
        SCENE_TITLE = 0
        SCENE_GAME
        SCENE_GAMEOVER

        //ビットフラグ
        TR_BIT_INIT    = 1 << 0
        TR_BIT_SCORE   = 1 << 1
        TR_BIT_HISCORE = 1 << 2
        TR_BIT_ANIM    = 1 << 3
        TR_BIT_POS     = 1 << 4

        //色
        COLOR_BACK    = 195
        COLOR_SKY     = 170
        COLOR_GROUND  = 140
        COLOR_CHARA   = 140
        COLOR_TEXT    = 120
        COLOR_SCORE   = 120
        COLOR_HISCORE = 160

        //アニメーション
        PL_STATE_NONE = 0
        PL_STATE_WAIT
        PL_STATE_FAILED
        PL_STATE_RUN
        PL_STATE_DUSH
        PL_STATE_JUMP_1
        PL_STATE_JUMP_2
        PL_STATE_JUMP_3
        PL_STATE_JUMP_4

        //プレイヤー
        PLAYER_X         = 40
        PLAYER_MAX_X     = 120
        PLAYER_HEIGHT    = 32
        PLAYER_UNIT      = 10
        PLAYER_JUMP      = -60
        PLAYER_GRAVITY   = 4
        PLAYER_SPEED     = 3
        PLAYER_MAX_SPEED = 5
        PLAYER_DUSH      = 2

        //友人
        FRIEND_NUM      = 3
        FRIEND_PATTERN  = 8
        FRIEND_INTERVAL = 24
        FRIEND_HEIGHT   = 32

        //障害物のタイプ
        OBS_TYPE_NONE = 0
        OBS_TYPE_CACTUS_1
        OBS_TYPE_CACTUS_2
        OBS_TYPE_CACTUS_3
        OBS_TYPE_GUILE
        OBS_TYPE_GUILE_KICK
        OBS_TYPE_NASU
        OBS_TYPE_WYVERN

        //障害物のメンバ
        MEM_OBS_TYPE = 0
        MEM_OBS_X
        MEM_OBS_Y
        SIZE_OF_OBS

        //障害物
        OBS_NUM    = 2
        OBS_X      = 320
        OBS_HEIGHT = 48
        OBS_RND    = 80
        OBS_INTERVAL = 320

        //スコア
        COUNTER_WIDTH = 8
        SCORE_DIGIT = 4
        SCORE_MAX = 9999
        SCORE_INTERVAL = 16
        SCORE_X = (320 - 16)
        SCORE_Y = 4
        HISCORE_X = (320 - 64)
        HISCORE_Y = 4

        //定数
        OUT_RANGE = -320
        GROUND_Y = 80
        OFFSET_X = 0
        OFFSET_Y = 64
        TEXT_X = 0
        TEXT_Y = 32
    }

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

        mommothPicCmd = bl {
            PATH_MAMMOTH
            .center
            .grid(4, 4)
            basePicCmd
        }

        friendPicCmd = bl {
            PATH_FRIEND
            .center
            .grid(4, 4)
            basePicCmd
        }

        obstractPicCmd = bl {
            PATH_OBSTRACT
            .center
            .grid(4, 2)
            basePicCmd
        }

        countPicCmd = bl {
            PATH_COUNT
            .topRight
            .grid(10, 1)
            basePicCmd
        }

        textPicCmd = bl {
            PATH_TEXT
            .topLeft
            .grid(1, 2)
            basePicCmd
        }
    }

    defv {
        varHead = TV_MINIGAME
        
        ipt
        ele
        idx
        ptr
        pid
        cell
        ax
        ay

        iptDush
        iptJump
        iptJumpType

        sceneState
        sceneTimer
        triggerFlg
        score
        scoreTimer
        speedStep
        obstractTimer
        offsetY
        groundScroll
        backScroll
        scrollBaseSpeed
        scrollAddSpeed

        playerState
        playerX
        playerY
        playerVy
        
        obsHead//+0_+6
        varFoot = (__id(obsHead) + OBS_NUM * SIZE_OF_OBS)

    }

    commentRangeOfVariables(varFoot, TV_MINIGAME, NUM_OF_VAR, NUM_OF_STR, NUM_OF_PIC)
    
    //メタ変数
    $SCROLL_SPEED = (scrollBaseSpeed + scrollAddSpeed)
                
    //数値を表示する
    __fn _showCounter $num $pid $dig $x $y $col bl {
        ele = 1
        @loop $dig .dst(idx) bl {
            v[__id(ax)..__id(ay)] = [($x) - idx * COUNTER_WIDTH, ($y)]
            pid  = ($pid) + idx
            cell = 1 + ($num) % (ele * 10) / ele
            @pic.show [pid] .pos(ax, ay) .topRight .cell(cell) .rgbs($col, $col, $col, 100) countPicCmd
            //次の桁
            ele *= 10
        }
    }

    //障害物のポインタを取得する
    __fn _getObstractPtr $dvDst $idx bl {
        v[__id($dvDst)] = __id(obsHead) + ($idx) * SIZE_OF_OBS
    }

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

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

    //------------------------------------------------------------------------------------
    //開始処理
    bl {
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, 0, 0)
        msgBottom()
        
        @scr.tint .rgbs(50, 50, 50, 100) .time(1)

        //ピクチャ
        @pic.show [PIC_BACK] PATH_BASE .pos(OFFSET_X + 160, OFFSET_Y + 48) .center .scale2(100 * 320 / 16, 100 * 96 / 16) .rgbs(COLOR_BACK, COLOR_BACK, COLOR_BACK, 100) basePicCmd
        @pic.show [PIC_TEXT] .pos(OUT_RANGE, OUT_RANGE) .cell(0) textPicCmd

        //キャラクター
        @pic.show [PIC_MAMMOTH] .pos(OUT_RANGE, OUT_RANGE) .scale(100) .cell(0) mommothPicCmd

        //友人
        @loop FRIEND_NUM  .dst(idx) bl {
            pid = PIC_FRIEND + idx
            @pic.show[pid] .pos(OUT_RANGE, OUT_RANGE) .cell(0) friendPicCmd
        }

        //障害物
        @loop OBS_NUM .dst(idx) bl {
            pid = PIC_OBSTRACT + idx
            @pic.show[pid] .pos(OUT_RANGE, OUT_RANGE) .cell(0) obstractPicCmd
        }

        //背景
        @loop 2 .dst(idx) bl {
            pid = PIC_GROUND + idx
            @pic.show [pid] PATH_GROUND .pos(OUT_RANGE, OUT_RANGE) .topLeft .scale(100) .rgbs(COLOR_GROUND, COLOR_GROUND, COLOR_GROUND, 100) basePicCmd
            pid = PIC_SKY + idx
            @pic.show [pid] PATH_SKY .pos(OUT_RANGE, OUT_RANGE) .topLeft .scale(100) .rgbs(COLOR_SKY, COLOR_SKY, COLOR_SKY, 100) basePicCmd
        }

        //スコア
        @loop SCORE_DIGIT .dst(idx) bl {
            pid = PIC_SCORE + idx
            @pic.show [pid] .pos(OUT_RANGE, OUT_RANGE) countPicCmd
            pid = PIC_HISCORE + idx
            @pic.show [pid] .pos(OUT_RANGE, OUT_RANGE) countPicCmd
        }

        @label.jump "gameLoop"
    }

    //------------------------------------------------------------------------------------
    //ゲーム処理
    @label.set "gameLoop"
    bl {
        //初期化
        _changeSceneState(SCENE_TITLE)

        triggerFlg = TR_BIT_INIT | TR_BIT_ANIM
        playerState = PL_STATE_WAIT

        iptDush = 0
        iptJump = 0
        iptJumpType = 0

        //----------------------------
        //ループ
        @loop bl {
            @wait(0)

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

            //----------------------------
            //入力
            @key.input .dst(ipt) {
                .right
                .shift
            }
            iptDush = ipt ? iptDush + 1 : 0

            @key.input .dst(iptJumpType) {
                .up
                .down
                .left
                .decision
            }
            iptJump = iptJumpType ? iptJump + 1 : 0

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

            //----------------------------
            //ゲーム中
            @if sceneState == SCENE_GAME bl {
                //----------------------------
                //揺れを戻す
                @if offsetY > 0 bl {
                    offsetY -= 1
                }

                //----------------------------
                //プレイヤー
                bitOn(triggerFlg, TR_BIT_POS)

                //地面にいる
                @if `playerY + PLAYER_HEIGHT / 2 >= GROUND_Y bl {
                    //ダッシュ
                    @if `iptDush bl {
                        @if `!scrollAddSpeed bl {
                            bitOn(triggerFlg, TR_BIT_ANIM)
                            scrollAddSpeed  = PLAYER_DUSH
                            playerState = PL_STATE_DUSH
                        }
                    //ダッシュ中止
                    } .elif `scrollAddSpeed bl {
                        bitOn(triggerFlg, TR_BIT_ANIM)
                        scrollAddSpeed  = 0
                        playerState = PL_STATE_RUN
                    }

                    @if `iptJump bl {
                        playerVy = PLAYER_JUMP
                        playerY += playerVy / PLAYER_UNIT

                        bitOn(triggerFlg, TR_BIT_ANIM)
                        //ボタンによってモーションが変わる
                        @if iptJumpType == KEY_DECISION bl {
                            playerState = PL_STATE_JUMP_1
                        } .elif iptJumpType == KEY_DOWN bl {
                            playerState = PL_STATE_JUMP_2
                        } .elif iptJumpType == KEY_LEFT bl {
                            playerState = PL_STATE_JUMP_3
                        } .elif iptJumpType == KEY_UP bl {
                            playerState = PL_STATE_JUMP_4
                        }
                        @se.play "Jump2" .opt(70, 100, 50)
                    }

                //空中にいる
                } .else bl {
                    playerVy += PLAYER_GRAVITY
                    playerY  += playerVy / PLAYER_UNIT
                    //着地
                    @if `playerY + PLAYER_HEIGHT / 2 >= GROUND_Y bl {
                        bitOn(triggerFlg, TR_BIT_ANIM)
                        playerState = scrollAddSpeed ? PL_STATE_DUSH : PL_STATE_RUN
                        playerY = GROUND_Y - PLAYER_HEIGHT / 2
                        playerVy = 0
                        offsetY += 2
                    }
                }

                //----------------------------
                //障害物
                obstractTimer += $SCROLL_SPEED
                //障害物が定期的に発生する
                @if obstractTimer >= OBS_INTERVAL bl {
                    obstractTimer = rnd(0, OBS_RND)
                    //速度が変わる瞬間の事故を防ぐ
                    //スコアがカンストすると速度が変わらないので必要ない
                    @if `score >= SCORE_MAX - 100 || between(score % 1000, 30, 1000 - 30 ) bl {
                        //障害物発生
                        @loop OBS_NUM .dst(idx) bl {
                            _getObstractPtr(ptr, idx)
                            @if `v[ptr + MEM_OBS_TYPE] != OBS_TYPE_NONE bl {
                                @continue
                            }
                            //タイプ
                            //サボテンの確率が高い
                            ele = [1, 1, 2, 3, 4, 6, 7][rnd(0, 6)]
                            //ピクチャID
                            pid = PIC_OBSTRACT + idx
                            //メンバー変数
                            v[ptr + MEM_OBS_TYPE] = ele
                            v[ptr + MEM_OBS_X] = OBS_X + OBS_HEIGHT / 2
                            v[ptr + MEM_OBS_Y] = GROUND_Y - OBS_HEIGHT / 2
                            //なすーんとワイバーンは確率で高さが変わる
                            @if `ele == OBS_TYPE_NASU || ele == OBS_TYPE_WYVERN bl {
                                @if `rnd(0, 99) < 50 bl {
                                    v[ptr + MEM_OBS_Y] -= 24
                                }
                            }

                            //ピクチャを設置する
                            @if `ele == OBS_TYPE_CACTUS_1 ||
                                ele == OBS_TYPE_CACTUS_2 ||
                                ele == OBS_TYPE_CACTUS_3 ||
                                ele == OBS_TYPE_GUILE ||
                                ele == OBS_TYPE_WYVERN bl {
                                cell = [0, 1, 2, 3, 4, 5, 6, 8][ele]
                                @pic.show [pid] .pos(OUT_RANGE, OUT_RANGE) .cell(cell) .rgbs(COLOR_CHARA, COLOR_CHARA, COLOR_CHARA, 100) obstractPicCmd

                            } .elif ele == OBS_TYPE_NASU bl {
                                @pic.show [pid] .pos(OUT_RANGE, OUT_RANGE) .rangeAnim(8, 6, 7) .repeat .rgbs(COLOR_CHARA, COLOR_CHARA, COLOR_CHARA, 100) obstractPicCmd
                            }
                            //発生は一つだけ
                            @break
                        }
                        //満杯の場合は何もしない
                    }
                }

                //各障害物を更新する
                @loop OBS_NUM .dst(idx) bl {
                    _getObstractPtr(ptr, idx)
                    @if `v[ptr + MEM_OBS_TYPE] == OBS_TYPE_NONE bl {
                        @continue
                    }
                    //タイプ
                    ele = v[ptr + MEM_OBS_TYPE]
                    //ピクチャID
                    pid = PIC_OBSTRACT + idx
                    //ガイル
                    @if ele == OBS_TYPE_GUILE bl {
                        v[ptr + MEM_OBS_X] -= $SCROLL_SPEED
                        //近寄るとパターンが変わる
                        @if `playerX + 96 > v[ptr + MEM_OBS_X] bl {
                            //サマソ
                            v[ptr + MEM_OBS_TYPE] = OBS_TYPE_GUILE_KICK
                            v[ptr + MEM_OBS_Y] -= 24
                            //ピクチャの現在位置
                            @pic.getInfo [pid] .currentRect(ax, ay, 0, 0) .cewh
                            ay -= 24
                            @pic.show [pid] .pos(ax, ay) .center .cell(5) .rgbs(COLOR_CHARA, COLOR_CHARA, COLOR_CHARA, 100) obstractPicCmd
                        }
                    //なすーん or ワイバーン
                    } .elif `ele == OBS_TYPE_NASU || ele == OBS_TYPE_WYVERN bl {
                        //元ネタと異なり、速度が速い
                        v[ptr + MEM_OBS_X] -= $SCROLL_SPEED + 1
                    //その他
                    } .else bl {
                        v[ptr + MEM_OBS_X] -= $SCROLL_SPEED
                    }

                    //衝突判定
                    //無敵モード中は判定を行わない
                    @if invincibleSwitch.isOff bl {
                        @if `abs(playerX - v[ptr + MEM_OBS_X]) < [ 0, 12, 14, 24,  0, 18, 12, 20 ][ele] &&
                             abs(playerY - v[ptr + MEM_OBS_Y]) < [ 0, 20, 22, 12,  0, 18, 12, 20 ][ele] bl {
                            bitOn(triggerFlg, TR_BIT_ANIM)
                            playerState = PL_STATE_FAILED
                        }
                    }

                    //消滅判定
                    @if `v[ptr + MEM_OBS_X] + OBS_HEIGHT / 2 < 0 bl {
                        v[ptr + MEM_OBS_TYPE] = OBS_TYPE_NONE
                        @pic.move [pid] .pos(OUT_RANGE, OUT_RANGE) .center
                    }
                }

                //ゲームオーバー判定
                @if playerState == PL_STATE_FAILED bl {
                    _changeSceneState(SCENE_GAMEOVER)
                    @se.play "bom0" .opt(80, 100, 50)
                }

                //----------------------------
                //スクロール
                @if `$SCROLL_SPEED != 0 bl {
                    groundScroll = (groundScroll - $SCROLL_SPEED     + 320) % 320
                    backScroll   = (backScroll   - $SCROLL_SPEED / 2 + 320) % 320
                    //スコアが最大値以下
                    @if score < SCORE_MAX bl {
                        //スコア
                        scoreTimer += $SCROLL_SPEED
                        @if scoreTimer >= SCORE_INTERVAL bl {
                            bitOn(triggerFlg, TR_BIT_SCORE)

                            scoreTimer -= SCORE_INTERVAL
                            score += 1
                            
                            //50ごとにプレイヤーが前に出てくる
                            @if `!(score % 50) bl {
                                playerX = min(playerX + 1, PLAYER_MAX_X)
                            }
                            //100ごとに効果音が鳴る
                            @if `!(score % 100) bl {
                                @se.play "pon" .opt(80, 100, 50)
                            }
                            //1000ごとに加速する
                            @if `!(score % 1000) bl {
                                //最大速度に達していた場合は、減速する
                                @if scrollBaseSpeed >= PLAYER_MAX_SPEED bl {
                                    speedStep = -1
                                } .elif scrollBaseSpeed <= PLAYER_SPEED bl {
                                    speedStep = 1
                                }

                                //効果音
                                @if speedStep > 0 bl {
                                    @se.play "Buff" .opt(100, 100, 50)
                                } .else bl {
                                    @se.play "Debuff" .opt(100, 100, 50)
                                }
                                scrollBaseSpeed += speedStep

                                //実績
                                checkSetAchievement(achievedMommoth, score >= ACHIEVE_SCORE)
                            }
                            //スコアがカンストした
                            @if `score >= SCORE_MAX bl {
                                @se.play "itemget2" .opt(100, 100, 50)
                            }
                        }
                    }
                }
            //----------------------------
            //タイトル / ゲームオーバー
            } .elif `sceneState == SCENE_TITLE || sceneState == SCENE_GAMEOVER bl {
                @if scenetimer == 0 bl {
                    //ハイスコアの更新判定
                    _updateHighScore()
                    //文字
                    cell = (sceneState == SCENE_TITLE) ? 1 : 2
                    @pic.show [PIC_TEXT] .pos(OFFSET_X + TEXT_X, OFFSET_Y + TEXT_Y) .cell(cell) .rgbs(COLOR_TEXT, COLOR_TEXT, COLOR_TEXT, 100) textPicCmd
                }

                //ゲーム開始
                //すぐには始まらないように間を設ける
                @if sceneTimer >= 20 bl {
                    @if `iptJump bl {
                        _changeSceneState(SCENE_GAME)

                        bitOn(triggerFlg, TR_BIT_INIT | TR_BIT_ANIM)
                        playerState = PL_STATE_RUN

                        //ピクチャを非表示にする
                        @pic.move[PIC_TEXT] .pos(OUT_RANGE, OUT_RANGE)
                    }
                }
            }

            //----------------------------
            //トリガー
            @if `triggerFlg bl {
                //ゲームを初期化する
                @if `triggerFlg & TR_BIT_INIT bl {
                    bitOff(triggerFlg, TR_BIT_INIT)
                    bitOn(triggerFlg, TR_BIT_SCORE | TR_BIT_HISCORE | TR_BIT_POS)

                    score         = 0
                    scoreTimer    = 0
                    speedStep     = 1
                    obstractTimer = 0
                    offsetY       = 0
                    groundScroll  = 0
                    backScroll    = 0
                    scrollBaseSpeed  = PLAYER_SPEED
                    scrollAddSpeed   = 0

                    //プレイヤーの状態はシーン更新時に初期化する
                    V2_set(playerX, PLAYER_X, GROUND_Y - PLAYER_HEIGHT / 2)
                    playerVy = 0

                    //友人を決める
                    ele = rnd(0, FRIEND_PATTERN - 1)
                    @loop FRIEND_NUM .dst(idx) bl {
                        pid = PIC_FRIEND + idx
                        ele = (ele + 1) % FRIEND_PATTERN

                        __fn _setFriendPattern $f $c1 $c2 bl {
                            @pic.show [pid] .pos(OUT_RANGE, OUT_RANGE) .rangeAnim($f, $c1, $c2) .repeat .rgbs(COLOR_CHARA, COLOR_CHARA, COLOR_CHARA, 100) friendPicCmd
                        }

                        __loop [bl { _setFriendPattern(8, 1, 2) },
                            bl { _setFriendPattern(8, 3, 4) },
                            bl { _setFriendPattern(8, 5, 6) },
                            bl { _setFriendPattern(8, 7, 8) },
                            bl { _setFriendPattern(8, 9,10) },
                            bl { _setFriendPattern(8,11,12) },
                            bl { _setFriendPattern(8,13,14) },
                            bl { _setFriendPattern(8,15,16) }
                        ] $block $idx bl {
                            @if ele == $idx bl {
                                $block
                            }
                        }
                    }

                    //障害物を片付ける
                    @loop OBS_NUM .dst(idx) bl {
                        _getObstractPtr(ptr, idx)
                        v[ptr..ptr + SIZE_OF_OBS - 1] = 0

                        pid = PIC_OBSTRACT + idx
                        @pic.move[pid] .pos(OUT_RANGE, OUT_RANGE)
                    }
                }

                //プレイヤーのアニメーションを変更する
                @if `triggerFlg & TR_BIT_ANIM bl {
                    bitOff(triggerFlg, TR_BIT_ANIM)

                    //ピクチャの現在位置
                    @pic.getInfo [PIC_MAMMOTH] .currentRect(ax, ay, 0, 0) .cewh

                    //セルを変えるか、アニメーションを設定する
                    __fn _setMommothPattern $f $c1 $c2 bl {
                        __if $f == 0 bl {
                            @pic.show [PIC_MAMMOTH] .pos(ax, ay) .cell($c1) .rgbs(COLOR_CHARA, COLOR_CHARA, COLOR_CHARA, 100) mommothPicCmd
                        } .else bl {
                            @pic.show [PIC_MAMMOTH] .pos(ax, ay) .rangeAnim($f, $c1, $c2) .repeat .rgbs(COLOR_CHARA, COLOR_CHARA, COLOR_CHARA, 100) mommothPicCmd
                        }
                    }

                    __loop [bl {},
                        bl { _setMommothPattern(0, 1, 0) },
                        bl { _setMommothPattern(0, 3, 0) },
                        bl { _setMommothPattern(6, 1, 2) },
                        bl { _setMommothPattern(4, 5, 6) },
                        bl { _setMommothPattern(0, 4, 0) },
                        bl { _setMommothPattern(0, 7, 0) },
                        bl { _setMommothPattern(6, 9, 12) },
                        bl { _setMommothPattern(6, 13, 16) }
                    ] $block $idx bl {
                        @if playerState == $idx bl {
                            $block
                        }
                    }
                }

                //キャラクターと背景の位置を更新する
                @if `triggerFlg & TR_BIT_POS bl {
                    bitOff(triggerFlg, TR_BIT_POS)

                    //プレイヤー
                    V2_set(ax, playerX + OFFSET_X, playerY + offsetY + OFFSET_Y)
                    @pic.move[PIC_MAMMOTH] .pos(ax, ay) .center .keepRgbs
                    //友人
                    //プレイヤーを追従する
                    V2_set(ax, playerX - 28 - FRIEND_INTERVAL + OFFSET_X, offsetY - FRIEND_HEIGHT / 2 + GROUND_Y  + OFFSET_Y)
                    @loop FRIEND_NUM .dst(idx) bl {
                        pid = PIC_FRIEND + idx
                        @pic.move[pid] .pos(ax, ay) .center .keepRgbs

                        ax -= FRIEND_INTERVAL
                    }

                    //障害物
                    @loop OBS_NUM .dst(idx) bl {
                        _getObstractPtr(ptr, idx)

                        @if `v[ptr + MEM_OBS_TYPE] == OBS_TYPE_NONE bl {
                            @continue
                        }

                        pid = PIC_OBSTRACT + idx
                        V2_set(ax, v[ptr + MEM_OBS_X] + OFFSET_X, v[ptr + MEM_OBS_Y] + offsetY + OFFSET_Y)
                        @pic.move[pid] .pos(ax, ay) .center .keepRgbs
                    }

                    //背景
                    @loop 2 .dst(idx) bl {
                        pid = PIC_GROUND + idx
                        V2_set(ax, OFFSET_X + groundScroll + (idx - 1) * 320, OFFSET_Y + offsetY + (96 - 32) )
                        @pic.move [pid] .pos(ax, ay) .topLeft .keepRgbs

                        pid = PIC_SKY + idx
                        V2_set(ax, OFFSET_X + backScroll + (idx - 1) * 320, OFFSET_Y + offsetY + (96 - 48 - 20) )
                        @pic.move [pid] .pos(ax, ay) .topLeft .trans(50) .keepRgbs
                    }

                }

                //スコア
                @if `triggerFlg & TR_BIT_SCORE bl {
                    bitOff(triggerFlg, TR_BIT_SCORE)
                    _showCounter(score, PIC_SCORE, SCORE_DIGIT, OFFSET_X + SCORE_X, OFFSET_Y + SCORE_Y, COLOR_SCORE)
                }

                //ハイスコア
                @if `triggerFlg & TR_BIT_HISCORE bl {
                    bitOff(triggerFlg, TR_BIT_HISCORE)
                    _showCounter(mammothGameScore, PIC_HISCORE, SCORE_DIGIT, OFFSET_X + HISCORE_X, OFFSET_Y + HISCORE_Y, COLOR_HISCORE)
                }
            }
        }
    }

    //------------------------------------------------------------------------------------
    //終了する
    @label.set "gameEnd"
    bl {
        _updateHighScore()

        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, 0, 0)
        @scr.tint .rgbs(100, 100, 100, 100) .time(1) .wait
    }
}