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


cev[CEV_GRA_CATCHER] .name("mg_ほこグラキャッチャー") {

    def {
        NUM_OF_VAR = 256
        NUM_OF_STR = 0
        NUM_OF_PIC = 64

        BASE_LAYER = 6

        PATH_CASE1  = "hc\case1"
        PATH_CASE2  = "hc\case2"
        PATH_CASE3  = "hc\case3"
        PATH_POLE   = "hc\pole"
        PATH_ARM    = "hc\arm"
        PATH_CLAW   = "hc\claw"
        PATH_EFFECT = "hc\effect"
        PATH_PRIZE  = "hc\prize"

        PIC_HEAD       = 1
        PIC_CASE_BACK  = 2//奥
        PIC_PRIZE_BACK = 3//+0_+15
        PIC_CASE_MID   = 20//中
        PIC_ARM_POLE   = 21
        PIC_ARM_BODY   = 22
        PIC_ARM_L      = 23
        PIC_ARM_R      = 24
        PIC_PRIZE_MID  = 34//+0_+15
        PIC_CASE_FRONT = 50//手前
        PIC_PRIZE_LIST = 51//+0_+4
        PIC_GET_EFFECT = 56//*0_+1
        PIC_PRIZE_GET  = 58
        PIC_DEBUG      = 59

        //定数
        UNIT_POS = 100
        UNIT_ANG = 10

        GET_EFFECT_X = 160
        GET_EFFECT_Y = 120

        LIST_X = (160 - 40)
        LIST_Y = 18
        LIST_REPEAT = 10
        LIST_NUM    = 5
        LIST_WIDTH  = 20

        STAGE_TOP    = ( 16 * UNIT_POS)
        STAGE_BOTTOM = (192 * UNIT_POS)
        STAGE_LEFT   = ( 76 * UNIT_POS)
        STAGE_RIGHT  = ((320 - 76) * UNIT_POS)

        RELOAD_X = (224 * UNIT_POS)
        RELOAD_Y = ( 24 * UNIT_POS)
        RELOAD_NUM  = 8
        RELOAD_TIME = 8

        HOLE_X = (112 * UNIT_POS)
        HOLE_Y = (114 * UNIT_POS)
        HOLE_RAD   = (18 * UNIT_POS)
        HOLE_DEPTH = (224 * UNIT_POS)

        ARM_ACCEL  = (UNIT_POS * 4 / 100)
        ARM_ANGACC = (UNIT_ANG * 4 / 10)
        ARM_SLIDE  = 10
        ARM_X_WAIT = ( 96 * UNIT_POS)
        ARM_X_TERM = (216 * UNIT_POS)
        ARM_X_HOLE = (112 * UNIT_POS)
        ARM_Y_UP   = ( 72 * UNIT_POS)
        ARM_Y_DOWN = (152 * UNIT_POS)
        ARM_CLAW_X = (28 * UNIT_POS)
        ARM_CLAW_Y = (22 * UNIT_POS)
        ARM_OPEN_ANG  = (90 * UNIT_ANG)
        ARM_CLOSE_ANG = (30 * UNIT_ANG)
        ARM_ROUGH_RAD = (96 * UNIT_POS)
        ARM_ROOT_RAD = (4 * UNIT_POS)
        ARM_TIP_RAD  = (2 * UNIT_POS)
        ARM_CLAW_LENGTH = (20 * UNIT_POS)
        ARM_HIT_CORRECT = (UNIT_POS * 4 / 100)

        PRIZE_PATTERN     = (12 * 8)
        PRIZE_DRAW_DAMPER = 100
        PRIZE_DRAW_RAD    = (10 * UNIT_POS)
        PRIZE_RAD         = (10 * UNIT_POS)
        PRIZE_RAD2        = (12 * UNIT_POS)//景品同士の衝突に使用する
        PRIZE_GRAVITY     = (UNIT_POS * 16 / 100)
        PRIZE_REST_POS    = 1
        PRIZE_REST_VEL    = 4
        PRIZE_FRICTION    = 800
        PRIZE_REFLECTION  = 200

        PRIZE_STATE_NONE = 0
        PRIZE_STATE_WAIT
        PRIZE_STATE_NORMAL
        PRIZE_STATE_DROP

        PRIZE_NUM = 16
        SIZE_OF_PR = 10
        MP_STATE = 0
        MP_TYPE
        MP_CX
        MP_CY
        MP_AX
        MP_AY
        MP_VX
        MP_VY
        MP_DX
        MP_DY
    }

    //反復処理の内で使用する変数を定義する
    def {
        //idx2
        i2BitVar  = v[__id(graCatcherFlag1) + idx2 / 32]
        i2BitMask = (0x01 << (idx2) % 32)

        //idx1
        i1PidMid  = (PIC_PRIZE_MID + idx1)
        i1PidBack = (PIC_PRIZE_BACK + idx1)

        //ele1
        m1State = v[MP_STATE + ele1]
        m1Type  = v[MP_TYPE + ele1]
        m1Cx    = v[MP_CX + ele1]
        m1Cy    = v[MP_CY + ele1]
        m1Ax    = v[MP_AX + ele1]
        m1Ay    = v[MP_AY + ele1]
        m1Dx    = v[MP_DX + ele1]
        m1Dy    = v[MP_DY + ele1]
        m1Vx    = v[MP_VX + ele1]
        m1Vy    = v[MP_VY + ele1]

        //ele2
        m2State = v[MP_STATE + ele2]
        m2Cx    = v[MP_CX + ele2]
        m2Cy    = v[MP_CY + ele2]
        m2Ax    = v[MP_AX + ele2]
        m2Ay    = v[MP_AY + ele2]
        m2Vx    = v[MP_VX + ele2]
        m2Vy    = v[MP_VY + ele2]
    }

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

        backPicCmd = {
            .topLeft
            .pos(0, 0)
            .scale(100)
            .trans(0)
            .rgbs(100, 100, 100, 100)
            basePicCmd
        }

        readyPrizePicCmd = {
            PATH_PRIZE
            .center
            .pos(0, 0)
            .scale(100)
            .trans(100)
            .rgbs(100, 100, 100, 100)
            .grid(12, 8)
            basePicCmd
        }

        showListPicCmd = {
            PATH_PRIZE
            .center
            .grid(12, 8)
            basePicCmd
        }

        readyPicCmd = {
            .topLeft
            .pos(0, 0)
            .scale(100)
            .trans(100)
            .rgbs(100, 100, 100, 100)
            basePicCmd
        }

        hidePicCmd = {
            .pos(0, 0) .topLeft
            .scale(100)
            .trans(100)
        }
    }

    defv {
        varHead = TV_MINIGAME
        
        ipt
        idx1
        ele1
        idx2
        ele2
        ang1
        ang2
        ax1
        ay1
        ax2
        ay2
        pid
        cell
        time
        dot
        cx
        cy
        nx
        ny
        vx
        vy

        reloadCnt
        reloadTimer
        listInput
        listDir
        listIdx
        effectId
        effectTimer
        armInput
        armState
        armTimer
        armX
        armY
        armVx
        armVy
        armTgX
        armTgY
        armAng
        armAngVel
        armTgAng
        prHeader//16 * 10 = 160

        varFoot = __id(prHeader) + SIZE_OF_PR * PRIZE_NUM

    }

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

    //変数位置を取得する
    __fn _getPrizePtr $d $idx {
        v[__id($d)] = __id(prHeader) + SIZE_OF_PR * ($idx)
    }

    //------------------------------------------------------------------------------------
    //開始処理
    bl {
        initPicturesAndVariables(PIC_HEAD, NUM_OF_PIC, TV_MINIGAME, NUM_OF_VAR, 0, 0)
        msgBottom()
        
        //アーム
        armState = 0
        V2_set(armX, ARM_X_WAIT, ARM_Y_UP)
        V2_copy(armTgX, armX)
        armAng = ARM_CLOSE_ANG
        armTgAng = armAng
        //即リロード
        reloadCnt = PRIZE_NUM
        //リスト更新
        listDir = 1
        //暴発防止
        armInput = 2

        //背景
        @pic.show[PIC_CASE_FRONT] PATH_CASE1 backPicCmd
        @pic.show[PIC_CASE_MID]   PATH_CASE2 backPicCmd
        @pic.show[PIC_CASE_BACK]  PATH_CASE3 backPicCmd
        //アーム
        @pic.show[PIC_ARM_POLE] PATH_POLE readyPicCmd
        @pic.show[PIC_ARM_BODY] PATH_ARM  readyPicCmd
        @pic.show[PIC_ARM_L]    PATH_CLAW readyPicCmd
        @pic.show[PIC_ARM_R]    PATH_CLAW .vrev readyPicCmd
        //取得エフェクト
        @pic.show[PIC_GET_EFFECT+0] PATH_EFFECT .grid(3, 1) .cell(1) .rangeAnim(2, 1, 2) readyPicCmd
        @pic.show[PIC_GET_EFFECT+1] PATH_EFFECT .grid(3, 1) .cell(3) readyPicCmd
        @pic.show[PIC_PRIZE_GET] .cell(1) readyPrizePicCmd

        //リスト
        @loop LIST_NUM .dst(idx1) bl {
            pid = PIC_PRIZE_LIST + idx1
            @pic.show[pid] .cell(1) readyPrizePicCmd
        }

        //景品
        @loop PRIZE_NUM .dst(idx1) bl {
            pid = i1PidMid
            @pic.show[pid] .cell(1) readyPrizePicCmd
        }

        //暗転
        fastFadeInTintOnly(1)
        //ゲーム開始
        @label.jump "gameLoop"
    }

    //------------------------------------------------------------------------------------
    //ゲーム処理
    @label.set "gameLoop"
    bl {
        @loop bl {
            @wait(0)

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

            //----------------------------
            //入力
            @key.input .dst(ipt) {
                .decision
                .down
            }

            armInput = (ipt != 0) ? (armInput + 1) : 0

            //----------------------------
            //リスト
            @key.input .dst(ipt) {
                .left
                .right
            }

            //入力していないか、入力方向が反転したとき、カウンタを初期化する
            idx1 = (ipt == KEY_RIGHT ? 1 : -1)
            listInput = (ipt == 0 || listInput * idx1 < 0) ? 0 : ( listInput + idx1 )

            //表示位置を移動させる
            @if `abs(listInput) % LIST_REPEAT == 1 bl {
                listDir = (listInput > 0) ? 1 : -1
                listIdx = (listIdx + listDir + PRIZE_PATTERN) % PRIZE_PATTERN
                @se.play "Cursor1" .opt(90, 100, 50)
            }

            //リストを更新する
            @if listDir != 0 bl {
                @loop LIST_NUM .dst(idx1) bl {
                    //景品番号
                    idx2 = (listIdx + idx1 + PRIZE_PATTERN) % PRIZE_PATTERN
                    //ピクチャID
                    pid = PIC_PRIZE_LIST + idx1
                    //セル番号
                    cell = idx2 + 1

                    //取得していない人形は白くなる
                    ele1 = (i2BitVar & i2BitMask) != 0x00 ? 100 : 200
                    //中心でない人形は少し小さくなる
                    ele2 = (idx1 == LIST_NUM / 2) ? 100 : 75

                    //スクロール移動
                    V2_set(ax1, LIST_X + idx1 * LIST_WIDTH, LIST_Y)
                    V2_set(ax2, ax1 + listDir * LIST_WIDTH, LIST_Y)
                    
                    @pic.show[pid] .pos(ax2, ay2) .scale(ele2) .trans(100) .cell(cell) .rgbs(ele1, ele1, ele1, ele1) showListPicCmd
                    @pic.move[pid] .pos(ax1, ay1) .scale(ele2) .trans(0) .keepRgbs .time(1)
                }

                listDir = 0
            }

            //----------------------------
            //アーム

            //効果音
            __fn _armMoveSound $freq bl {
                @se.play "Magic1" .opt(70, $freq, 50)
            }

            __fn _armUpDownSound bl {
                @se.play "robotarm1" .opt(80, 60, 50)
            }

            __fn _armClawSound bl {
                @se.play "robotarm1" .opt(70, 150, 50)
            }

            idx1 = 0
            //入力待ち
            @if armState == 0 bl {
                //入力された
                @if armInput == 1 bl {
                    //発進
                    idx1 += 1
                    armTgX = ARM_X_TERM
                }

            //右へ移動する
            } .elif armState == 1 bl {
                //移動中はピロリロと鳴る
                @if `armTimer % 20 == 0 bl {
                    _armMoveSound(120)
                }

                //入力すると停止する
                @if `armInput == 1 bl {
                    idx1 += 1
                    //実際の停止位置は速度によってずれる
                    armTgX = clamp(armX + armVx * armVx / ARM_SLIDE, ARM_X_WAIT, ARM_X_TERM)
                //自動で止まる
                } .elif `armTgX <= armX bl {
                    idx1 += 1
                }

            //止まるまで待つ
            } .elif armState == 2 bl {
                @if armVx == 0 bl {
                    idx1 += 1
                    armTgAng = ARM_OPEN_ANG
                    _armClawSound()
                }

            //爪を上げつつ少し待つ
            } .elif armState == 3 bl {
                @if armTimer > 30 bl {
                    idx1 += 1
                    armTgY = ARM_Y_DOWN
                    _armUpDownSound()
                }

            //下へ移動する
            } .elif armState == 4 bl {
                @if armTimer > 120 bl {
                    idx1 += 1
                    armTgAng = ARM_CLOSE_ANG
                    _armClawSound()
                }

            //爪を閉じて少し待つ
            } .elif armState == 5 bl {
                @if armTimer > 40 bl {
                    idx1 += 1
                    armTgY = ARM_Y_UP
                    _armUpDownSound()
                }

            //上がる
            } .elif armState == 6 bl {
                @if armTimer > 80 bl {
                    idx1 += 1
                    armTgX = ARM_X_HOLE
                }

            //戻る
            } .elif armState == 7 bl {
                //移動中はピロリロと鳴る
                @if `armTimer % 20 == 0 bl {
                    _armMoveSound(100)
                }

                @if armTgX >= armX bl {
                    idx1 += 1
                }

            //少し待つ
            } .elif armState == 8 bl {
                @if armTimer > 40 bl {
                    idx1 += 1
                    armTgAng = ARM_OPEN_ANG
                    _armClawSound()
                }

            //開いて少し待つ
            } .elif armState == 9 bl {
                @if armTimer > 60 bl {
                    idx1 += 1
                    armTgX = ARM_X_WAIT
                    armTgAng = ARM_CLOSE_ANG
                    _armClawSound()
                }

            //持ち場に戻る
            } .elif armState == 10 bl {
                @if armTimer > 30 bl {
                    idx1 += 1

                    //リロード
                    reloadCnt = RELOAD_NUM
                }

            }

            //タイマー
            armTimer += 1

            //状態を更新する
            @if idx1 > 0 bl {
                armState = (armState + idx1) % (10 + 1)
                armTimer = 0
            }

            //到着タイミングを測る
            updateSpeedToApproach(armVx, armTgX - armX, armVx, ARM_ACCEL)
            updateSpeedToApproach(armVy, armTgY - armY, armVy, ARM_ACCEL)
            updateSpeedToApproach(armAngVel, armTgAng - armAng, armAngVel, ARM_ACCEL)

            V2_asAdd(armX, armVx)
            armAng += armAngVel

            //本体
            V2_divScalar(ax1, armX, UNIT_POS)
            @pic.move[PIC_ARM_BODY] .pos(ax1, ay1) .center .scale(100) .trans(0)
            //柱
            //本体が下がると若干上がる
            ay1 -= ay1 / 10
            @pic.move[PIC_ARM_POLE] .pos(ax1, ay1) .bottom .scale(100) .trans(0)
            //右爪
            ang1 = armAng
            V2_set(ax1, (armX - ARM_CLAW_X) / UNIT_POS, (armY + ARM_CLAW_Y) / UNIT_POS)
            @pic.move[PIC_ARM_L] .pos(ax1, ay1) .center .scale(100) .trans(0) .angle(ang1, UNIT_ANG) .keepFlip
            //左爪
            ang1 = 180 * UNIT_ANG - armAng
            V2_set(ax1, (armX + ARM_CLAW_X) / UNIT_POS, (armY + ARM_CLAW_Y) / UNIT_POS)
            @pic.move[PIC_ARM_R] .pos(ax1, ay1) .center .scale(100) .trans(0) .angle(ang1, UNIT_ANG) .keepFlip

            //----------------------------
            //景品取得演出
            @if effectId > 0 bl {
                ele1 = effectId
                idx1 = 0
                //出現
                @if effectTimer == 0 bl {
                    V2_set(ax1, GET_EFFECT_X, GET_EFFECT_Y + 32)
                    cell = m1Type + 1
                    @pic.show[PIC_PRIZE_GET] .pos(ax1, ay1) .scale(100) .trans(50) .rgbs(200, 200, 200, 100) .cell(cell) showListPicCmd
                    @pic.move[PIC_PRIZE_GET] .relative .pos(0, -32) .scale(100) .trans(-50) .rgbs(100, 100, 100, 100) .time(1)

                    @pic.move[PIC_GET_EFFECT+0] .pos(GET_EFFECT_X, GET_EFFECT_Y) .scale(50) .trans(0)
                    @pic.move[PIC_GET_EFFECT+1] .pos(GET_EFFECT_X, GET_EFFECT_Y) .scale(50) .trans(0) .rotate(5)

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

                //後光
                @if effectTimer == 1 bl {
                    @pic.move[PIC_GET_EFFECT+0] .relative .pos(0, 0) .scale(100) .trans(0) .time(1)
                    @pic.move[PIC_GET_EFFECT+1] .relative .pos(0, 0) .scale(100) .trans(0) .rotate(5) .time(1)
                }

                //片付ける
                @if effectTimer == 60 bl {
                    //新しい人形を取得するとリストの表示位置を変える
                    idx2 = clamp( m1Type, 0, PRIZE_PATTERN)
                    @if `(i2BitVar & i2BitMask) == 0x00 {
                        //フラグを立てる
                        i2BitVar |= i2BitMask

                        //リストを移動させる
                        //負数になっても大丈夫
                        listIdx = idx2 - LIST_NUM / 2
                        listDir = 1

                        //加算
                        graCatcherCollect += 1

                        //実績
                        checkSetAchievement(achievedCatcher, graCatcherCollect == PRIZE_PATTERN)

                        //コンプリート達成時の演出
                        @if graCatcherCollect == PRIZE_PATTERN bl {
                            @scr.flash .once(2) .rgbv(31, 31, 31, 31)
                            @se.play "Chime2" .opt(100, 100, 50)
                            @se.play "cheers" .opt(100, 100, 50)


                        //通常の演出
                        } .else bl {
                            @se.play "Holy5" .opt(90, 100, 50)
                        }

                        //ピクチャを上方向にスライドさせながら隠す
                        @pic.move[PIC_PRIZE_GET] .relative .pos(0, -96) .scale(-100) .trans(100) .time(1)

                    } .else bl {
                        //ピクチャを隠す
                        @pic.move[PIC_PRIZE_GET] .relative .pos(0, 32) .scale(-100) .trans(100) .time(1)
                    }

                    //取得数増加
                    graCatcherNum += 1

                    //他のピクチャも隠す
                    @pic.move[PIC_GET_EFFECT+0] hidePicCmd
                    @pic.move[PIC_GET_EFFECT+1] hidePicCmd

                    //待機状態を解除する
                    m1State = PRIZE_STATE_NONE

                    //次を待つ
                    effectId = 0
                }

                //終わり
                @if effectTimer >= 90 bl {
                    effectId = 0
                } .else bl {
                    //タイマー
                    effectTimer += 1
                }
            }

            //----------------------------
            //補充
            @if `reloadCnt > 0 bl {
                reloadTimer += 1
                @if `reloadTimer % RELOAD_TIME == 0 bl {
                    //成否判定用フラグ
                    idx2 = FALSE
                    @loop PRIZE_NUM .dst(idx1) bl {
                        _getPrizePtr(ele1, idx1)
                        @if ` m1State != PRIZE_STATE_NONE bl {
                            @continue
                        }

                        m1State = PRIZE_STATE_NORMAL
                        m1Type = rnd(0, PRIZE_PATTERN - 1)
                        m1Cx = RELOAD_X + rnd(-PRIZE_RAD, PRIZE_RAD)
                        m1Cy = RELOAD_Y
                        m1Ax = m1Cx
                        m1Ay = m1Cy
                        m1Dx = 0
                        m1Dy = 0
                        m1Vx = 0
                        m1Vy = 4 * UNIT_POS

                        pid = i1PidMid
                        cell = m1Type + 1
                        @pic.show[pid] .cell(cell) readyPrizePicCmd

                        idx2 = TRUE
                        @break
                    }

                    //投入成功
                    @if idx2 == TRUE bl {
                        reloadCnt -= 1
                        @se.play "Fall2" .opt(70, 150, 50)

                    //空きがなかった
                    } .else bl {
                        reloadCnt = 0
                        reloadTimer = 0
                    }
                }
            }

            //----------------------------
            //景品
            //景品同士と壁との衝突
            @loop PRIZE_NUM .dst(idx1) bl {
                _getPrizePtr(ele1, idx1)
                @if ` m1State != PRIZE_STATE_NORMAL bl {
                    @continue
                }

                //ループ回数
                pid = PRIZE_NUM - idx1
                @loop pid .dst(idx2) bl {
                    idx2 += idx1 + 1
                    _getPrizePtr(ele2, idx2)

                    @if `m2State != PRIZE_STATE_NORMAL bl {
                        @continue
                    }

                    //めりこんだら緩やかに反発させる
                    $sumRad = (PRIZE_RAD2 * 2)
                    ax1 = m1Cx - m2Cx
                    ay1 = m1Cy - m2Cy
                    @if `abs(ax1) < $sumRad && abs(ay1) < $sumRad bl {
                        //距離
                        V2_mag(time, ax1)
                        @if time < $sumRad bl {
                            //距離がゼロの場合、右にあるものとする
                            @if time <= 0 bl {
                                V2_set(ax1, 2, 0)
                            }

                            dot = (PRIZE_RAD2 * 2 - time) / 2//距離が近いほど強い
                            ax1 *= dot
                            ay1 *= dot
                            ax2 = PRIZE_REST_POS * time//位置修正
                            ay2 = PRIZE_REST_VEL * time//斥力

                            m1Ax += ax1 / ax2
                            m1Ay += ay1 / ax2
                            m2Ax -= ax1 / ax2
                            m2Ay -= ay1 / ax2

                            m1Vx += ax1 / ay2
                            m1Vy += ay1 / ay2
                            m2Vx -= ax1 / ay2
                            m2Vy -= ay1 / ay2
                        }
                    }
                }

                //アームとの衝突判定
                //簡易判定
                @if `min( abs(m1Cx - armX), abs(m1Ax - armX) ) <= ARM_ROUGH_RAD ||
                    min( abs(m1Cy - armY), abs(m1Ay - armY) )  <= ARM_ROUGH_RAD bl {

                    @loop 2 .dst(idx2) bl {
                        //衝突時間
                        time = -1
                        
                        __fn _setArm $sx $sy $angS $angE bl {
                            V2_set(ax1, $sx, $sy)
                            v[__id(ang1)..__id(ang2)] = [$angS, $angE]
                        }

                        //左爪
                        @if idx2 == 0 bl {
                            _setArm(armX - ARM_CLAW_X, armY + ARM_CLAW_Y, armAng, armAng + armAngVel)
                        //右爪
                        } .elif idx2 == 1 bl {
                            _setArm(armX + ARM_CLAW_X, armY + ARM_CLAW_Y, 180 * UNIT_ANG - armAng, 180 * UNIT_ANG - armAng - armAngVel)
                        }

                        //アームと円の衝突判定
                        circleToRotatingSegment(time, cx, cy, nx, ny, unusedV, unusedV, vx, vy,
                        m1Cx, m1Cy, m1Ax, m1Ay, PRIZE_RAD, ax1, ay1, 0, ARM_ROOT_RAD, ARM_CLAW_LENGTH, ARM_TIP_RAD, ang1, ang2)

                        @if time >= 0 bl {
                            //アームの速度を加算する
                            V2_asAdd(vx, armVx)
                            //反射ベクトルを取得
                            getReflection(ax1, ay1, dot,
                            m1Vx, m1Vy, nx, ny, vx, vy, PRIZE_FRICTION, PRIZE_REFLECTION)
                            //法線との内積で反射ベクトルを代入するかを判定する
                            @if dot <= 0 bl {
                                m1Vx = ax1
                                m1Vy = ay1

                            }
                            //反射後の座標
                            m1Ax = cx + (UNIT_SECOND - time) * m1Vx / UNIT_SECOND + nx * ARM_HIT_CORRECT / UNIT_NORMAL
                            m1Ay = cy + (UNIT_SECOND - time) * m1Vy / UNIT_SECOND + ny * ARM_HIT_CORRECT / UNIT_NORMAL
                        }
                    }
                }

                //左壁
                @if ` m1Ax < STAGE_LEFT + PRIZE_RAD bl {
                    ax1 = STAGE_LEFT + PRIZE_RAD - m1Ax

                    m1Ax = STAGE_LEFT + PRIZE_RAD
                    m1Vx += ax1 / PRIZE_REST_VEL
                }

                //右壁
                @if ` m1Ax > STAGE_RIGHT - PRIZE_RAD bl {
                    ax1 = STAGE_RIGHT - PRIZE_RAD - m1Ax

                    m1Ax = STAGE_RIGHT - PRIZE_RAD
                    m1Vx += ax1 / PRIZE_REST_VEL
                }

                //天井判定
                @if ` m1Ay < STAGE_TOP + PRIZE_RAD bl {
                    ax1 = STAGE_TOP + PRIZE_RAD - m1Ay

                    m1Ay = STAGE_TOP + PRIZE_RAD
                    m1Vy += ax1 / PRIZE_REST_VEL
                }

                //床判定
                @if ` m1Ay > STAGE_BOTTOM - PRIZE_RAD bl {
                    ax1 = STAGE_BOTTOM - PRIZE_RAD - m1Ay

                    m1Ay = STAGE_BOTTOM - PRIZE_RAD
                    m1Vy += ax1 / PRIZE_REST_VEL
                    m1Vx /= 2
                }
            }

            //更新
            @loop PRIZE_NUM .dst(idx1) bl {
                _getPrizePtr(ele1, idx1)
                //状態を一時保存する
                ele2 = m1State
                //ピクチャのIDを交換する
                __fn _swapPrizePictureId $cur $tag bl {
                    pid  = $cur
                    cell = $tag
                    @pic.setId[pid] .swap(cell, 1) .ignoreError
                }

                //通常状態
                @if `ele2 == PRIZE_STATE_NORMAL bl {
                    //X軸が範囲内でかつ、Y軸が境界をまたぎかつ、下方向に移動しているとき
                    @if `between( m1Ax, HOLE_X - HOLE_RAD, HOLE_X + HOLE_RAD ) &&
                        m1Cy < HOLE_Y && m1Ay >= HOLE_Y &&
                        m1Vy > 0 bl {
                        
                        //状態とピクチャIDを変更する
                        m1State = PRIZE_STATE_DROP
                        _swapPrizePictureId(i1PidMid, i1PidBack)
                    }

                //落下中
                } .elif `ele2 == PRIZE_STATE_DROP bl {
                    //一番下に落ちると演出待ちの状態になる
                    @if `m1Cy >= HOLE_DEPTH bl {
                        m1State = PRIZE_STATE_WAIT
                        //ピクチャIDを元に戻しておく
                        _swapPrizePictureId(i1PidBack, i1PidMid)
                        //台ピクチャの裏に隠す
                        //以下の処理は省略する
                        @continue
                    }

                //待機中
                } .elif `ele2 == PRIZE_STATE_WAIT bl {
                    //空いた
                    @if effectId <= 0 bl {
                        //変数の場所を入力する
                        effectId = ele1
                        effectTimer = 0
                    }
                    //以下の処理は省略する
                    @continue

                //存在しない
                } .else bl {
                    @continue
                }

                //座標制限
                @if `ele2 == PRIZE_STATE_NORMAL bl {
                    m1Ax = clamp(m1Ax, STAGE_LEFT, STAGE_RIGHT)
                    m1Ay = clamp(m1Ay, STAGE_TOP,  STAGE_BOTTOM)
                } .else bl {
                    m1Ax = clamp(m1Ax, HOLE_X - HOLE_RAD, HOLE_X + HOLE_RAD)
                    m1Ay = clamp(m1Ay, STAGE_TOP, HOLE_DEPTH)
                }

                //描画位置を更新する
                //振動を抑える
                @if `abs( m1Dx - m1Ax ) > PRIZE_DRAW_DAMPER ||
                     abs( m1Dy - m1Ay ) > PRIZE_DRAW_DAMPER bl {
                    m1Dx = m1Ax
                    m1Dy = m1Ay
                }

                //ピクチャを更新する
                ax1 = m1Dx / UNIT_POS
                ay1 = m1Dy / UNIT_POS
                pid = ( m1State == PRIZE_STATE_NORMAL ) ? i1PidMid : i1PidBack
                @pic.move[pid] .pos(ax1, ay1) .center .scale(100) .trans(0)

                //重力
                m1Vy += PRIZE_GRAVITY

                //座標更新
                m1Cx = m1Ax
                m1Cy = m1Ay
                m1Ax += m1Vx
                m1Ay += m1Vy
            }
        }
    }

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