

//--------------------------------
//右ランプ
def {
    RIGHT_RAMP_X   = 13
    RIGHT_RAMP_Y   = 15
    RIGHT_RAMP_VEL = 6 * UNIT_POS
}
mev[MEV_RIGHT_RAMP] .pos(RIGHT_RAMP_X, RIGHT_RAMP_Y) .name("右ランプ")
mep[1] .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_MIDDLE bl {
        @ev.abort
    }

    //上がる
    pbBallToArea(temA, temB,
    GIM_LAYER_MID, self.id, SHARP_RECT, -90, 0, -24, -8, 12, 8)
    @if `temA >= 0 && temB > 0 bl {
        pbBallFunction(BA_FUNC_SET_LAYER, temA, GIM_LAYER_HI, 0, 0, 0)

        //ある程度の速さで入ると音が鳴る
        @if temB > RIGHT_RAMP_VEL bl {
            @se.play "Earth6" .opt(100, 120, 50)
        }

        //看板ボーナス
        @if boardDir == DIR_FACE_UP bl {
            cm_boardBonus()
        }
    }

    //下がる
    pbBallToArea(temA, temB,
    GIM_LAYER_HI, self.id, SHARP_RECT, 90, 0, -40, 8, 24, 24)//少し横に広げる
    @if `temA >= 0 && temB > 0 bl {
        pbBallFunction(BA_FUNC_SET_LAYER, temA, GIM_LAYER_MID, 0, 0, 0)

    }
}

//--------------------------------
//左ドロップ
def {
    LEFT_DROP_COUNT = 3
}
mev[MEV_LEFT_DROP] .pos(0, 21) .name("左レール終着点")
mep[1] .body(CHARSET_LANE, 4) .dir.up .anim.fixDir .priority.middle .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_LOW bl {
        @ev.abort
    }

    //上から下へ
    pbBallToArea(temA, unusedV,
    GIM_LAYER_HI, self.id, SHARP_RECT, 0, 0, 16 * 3 - 16, -4, 16 * 3 + 16, 16)
    @if `temA >= 0 bl {
        pbBallFunction(BA_FUNC_SET_LAYER, temA, GIM_LAYER_MID, 0, 0, 0)
        pbBallFunction(BA_FUNC_SET_VEL, temA, 0, 0, 0, 0)

        //スコア
        pbAddScore(NUM_TYPE_BONUS, BONUS_RAIL_TERM, 0)

        //カウント
        railTermCount += 1

        //エンリュウが加わる
        //既に加わっている場合は時間を回復させる
        @if enryuState == GIM_ST_HIDE bl {
            @if railTermCount >= LEFT_DROP_COUNT bl {
                //カウンタを初期化する
                railTermCount = 0

                enryuState = GIM_ST_ACTIVATED
                enryuTimer = ENRYU_SECOND * UNIT_FPS

                pbDisplay(DI_ST_NORMAL, __str("\c[2]エンリュウ参戦 (", ENRYU_SECOND,"s)"))

                @se.play "voice_soiya" .opt(100, 120, 50)
                @ev.flash [MEV_ENRYU] .rgbv(31, 31, 31, 31) .time(5)
            }
        } .elif enryuState == GIM_ST_ACTIVATED bl {
            @if enryuTimer > 0 bl {
                //カウンタを初期化する
                railTermCount = 0
                enryuTimer = min(enryuTimer + ENRYU_SECOND_ADD * UNIT_FPS, ENRYU_SECOND * UNIT_FPS)

                @se.play "voice_soiya" .opt(100, 120, 50)
                @ev.flash [MEV_ENRYU] .rgbv(31, 31, 31, 31) .time(5)
            }
        }

        @se.play "Chime1" .opt(100, 100, 50)
        @ev.setAction .self .freq(7) .skippable .act {
            .faceRight
            .faceDown
            .faceLeft
            .pause
            .pause
            .faceRight
            .faceUp
        }
    }
}

//--------------------------------
//トップレーン
def {
    TOP_LANE_Y       = 5
    TOP_LANE_BITMASK = 7
}
mev[MEV_TOP_LANE_1] .pos(10, TOP_LANE_Y - 1) .name("上レーン1")
mep[1] .body(CHARSET_LANE, 2) .anim.step .priority.low .dir(.down) bl {}
mev[MEV_TOP_LANE_2] .pos(12, TOP_LANE_Y + 0) .name("上レーン2")
mep[1] .body(CHARSET_LANE, 2) .anim.step .priority.low .dir(.down) bl {}
mev[MEV_TOP_LANE_3] .pos(14, TOP_LANE_Y + 1) .name("上レーン3")
mep[1] .body(CHARSET_LANE, 2) .anim.step .priority.low .dir(.down) .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_HIGH bl {
        @ev.abort
    }

    //３つのレーンの判定を１つのイベントで行う
    //a:index b:event id c:bit d:hit id
    @loop 3 .dst(idxA) bl {
        //スイッチID
        temC = 1 << idxA
        @if `!(topLaneFlag & temC) bl {
            //イベントID
            temB = MEV_TOP_LANE_1 + idxA
            //判定
            pbBallToArea(temD, unusedV,
            GIM_LAYER_MID, temB, SHARP_RECT, 0, 0, -8, -8, 8, 8)

            @if temD >= 0 bl {
                //スコア
                pbAddScore(NUM_TYPE_BONUS, BONUS_TOP_LANE, 0)
                //フラグ
                topLaneFlag |= temC
                //起動する
                @se.play "Wind2" .opt(100, 100, 50)
                @ev[temB].setAction .freq(8) .skippable .act {
                    .beginThrough
                    .moveDown
                    .moveDown
                    .moveDown
                    .moveDown
                    .faceUp
                    .moveUp
                    .moveUp
                    .moveUp
                    .moveUp
                    .faceDown
                    .setBody(CHARSET_LANE, 3)
                }
                //全て揃うとバンパーが変わる
                // bit 111
                @if `(topLaneFlag & TOP_LANE_BITMASK) == TOP_LANE_BITMASK bl {
                    //ファルコンミッション
                    temA = FALCON_AREA_TOP_LANE
                    cm_falconMission()

                    //動作が完了するまで待つ
                    @wait(25)

                    //フラグ初期化
                    topLaneFlag = 0
                    ///レーンの状態を戻す
                    @loop 3 .dst(idxB) bl {
                        temB = MEV_TOP_LANE_1 + idxB
                        @ev[temB].setAction .freq(8) .skippable .act {
                            .setBody(CHARSET_LANE, 2)
                        }
                        @ev[temB].flash .rgbv(31, 31, 31, 31) .time(2)
                    }

                    //トップバンパーの絵柄を変える
                    bumperPattern = (bumperPattern + 1) % TOP_BUMPER_PATTERN
                    cm_updateBumperPattern()

                    //トップバンパーの絵柄を変えてレベルアップさせる
                    @if topBumperLevel < MAX_TOP_BUMPER_LEVEL bl {
                        topBumperLevel += 1
                        topBumperTimer = TOP_BUMPER_TIMER

                        pbDisplay(DI_ST_NORMAL, __str("\c[2]トップバンパー Level Up！\"))

                        @ev.setAction [MEV_TOP_BUMPER_LEVEL] .freq(8) .act {}
                        @ev.addAction .face(topBumperLevel)//0-3
                    } .else bl {
                        //時間を補充する
                        topBumperTimer = TOP_BUMPER_TIMER
                    }

                    //一周した場合、ビデオモードの権利を得る
                    //ついでにマルチプライヤもゲット
                    @if bumperPattern == 0 bl {
                        pbAddScore(NUM_TYPE_MULTI, MULTI_TOP_BUMPER, 0)
                        pbDisplay(DI_ST_NORMAL, __str("\c[2]マルチプライヤー +", MULTI_TOP_BUMPER))

                        @if `!(iconFlag & ICON_BIT_VIDEO) bl {
                            iconOn(ICON_BIT_VIDEO)
                            cm_updateCenterHole()
                            pbDisplay(DI_ST_NORMAL, "\c[2]ビデオモードが解禁！")
                        }
                    }

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

//--------------------------------
//トップバンパー
def {
    TOP_BUMPER_X     = 11                //バンパーの中心マス座標
    TOP_BUMPER_Y     = 10
    TOP_BUMPER_RAD   = 8
    TOP_BUMPER_FRI   = 900
    TOP_BUMPER_REF   = 500
    TOP_BUMPER_VEL   = 3 * UNIT_POS / 2
    TOP_BUMPER_TIMER = 60 * UNIT_FPS

    MAX_TOP_BUMPER_LEVEL = 3
    TOP_BUMPER_NUM       = 3
    TOP_BUMPER_PATTERN   = 8
}
mev[MEV_TOP_BUMPER_1] .pos(TOP_BUMPER_X, TOP_BUMPER_Y - 2) .name("トップバンパー1")
mep[1] .body(CHARSET_TOP_BUMPER, 0) .anim.fixDir.step .priority.middle .dir(.up) bl {}
mev[MEV_TOP_BUMPER_2] .pos(TOP_BUMPER_X + 2, TOP_BUMPER_Y + 1) .name("トップバンパー2")
mep[1] .body(CHARSET_TOP_BUMPER, 0) .anim.fixDir.step .priority.middle .dir(.right) bl {}
mev[MEV_TOP_BUMPER_3] .pos(TOP_BUMPER_X - 2, TOP_BUMPER_Y + 1) .name("トップバンパー3")
mep[1] .body(CHARSET_TOP_BUMPER, 0) .anim.fixDir.step .priority.middle .dir(.down) bl {}

mev[MEV_TOP_BUMPER_LEVEL] .pos(TOP_BUMPER_X, TOP_BUMPER_Y) .name("トップバンパーのレベル")
mep[1] .body(CHARSET_EVENT_1, 0) .anim.fixDir.step .priority.low  .dir(.up) .parallel bl {
    @if topBumperTimer > 0 bl {
        countDownEvent(topBumperTimer, MEV_TOP_BUMPER_LEVEL)
        @if `topBumperTimer <= 0 && topBumperLevel > 0 bl {
            topBumperLevel -= 1
            @if topBumperLevel > 0 bl {
                topBumperTimer = TOP_BUMPER_TIMER
            }
            @ev.setAction .self .freq(8) .act {}
            @ev.addAction .face(topBumperLevel)
            @se.play "Debuff" .opt(70, 100, 50)
            @ev.flash .self .rgbv(0, 0, 0, 31) .time(5)
        }
    }

    //簡易判定
    @if `ROUGHLY_CHECK_BALL_HIGH bl {
        //３つのレーンの判定を１つのイベントで行う
        //a:index b:event id c:bit d:hit id
        @loop TOP_BUMPER_NUM .dst(idxA) bl {
            //イベントID
            temB = MEV_TOP_BUMPER_1 + idxA
            //判定
            pbUpdateBumper(temD, unusedV,
            GIM_LAYER_MID, TOP_BUMPER_FRI, TOP_BUMPER_REF, TOP_BUMPER_VEL,
            temB, SHARP_CIRCLE, TOP_BUMPER_RAD, 0, 0, 0, 0)
            @if temD >= 0 bl {
                //スコア
                temE = [1, 2, 4, 6][topBumperLevel] * BONUS_TOP_BUMPER
                pbAddScore(NUM_TYPE_BONUS, temE, 0)

                //演出
                @se.play "flipper2" .opt(100, 100, 50)
                @se.play "bell1" .opt(70, 120, 50)
                @ev.flash [temB] .rgbv(31, 31, 31, 31) .time(4)
            }
        }
    }
}

//--------------------------------
//バンパー回転スイッチ
def {
    BUMPER_SWITCH_ANIM  = 9
    BUMPER_SWITCH_FRI   = 200
    BUMPER_SWITCH_REF   = 200
    BUMPER_SWITCH_VEL   = 1 * UNIT_POS
    BUMPER_SWITCH_COUNT = 3
    MAX_BUMPER_SWITCH   = 3
}

mev[MEV_BUMPER_SWITCH] .pos(8, 5) .name("バンパー回転スイッチ")
mep[1] .body(CHARSET_TARGET_1, 1) .dir.up .anim.fixDir.step .priority.middle .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_HIGH bl {
        @ev.abort
    }
    //判定
    pbUpdateBumper(temA, unusedV,
    GIM_LAYER_MID, BUMPER_SWITCH_FRI, BUMPER_SWITCH_REF, BUMPER_SWITCH_VEL,
    self.id, SHARP_SEGMENT, 0, 12,10, 12, 22)
    @if temA >= 0 bl {
        //スコア
        pbAddScore(NUM_TYPE_BONUS, BONUS_BUMPER_SWITCH, 0)
        //カウント
        topBumperSwitchCount += 1
        //バンパーの位置を変える
        @if `!(topBumperSwitchCount % BUMPER_SWITCH_COUNT) bl {
            //停止
            startEventMode()
            //発動演出
            @se.play "Magic1" .opt(100, 100, 50)
            @ev.flash .self .rgbv(31, 31, 31, 31) .time(5)
            @ev.setAction .self .freq(8) .skippable .act {
                .faceRight
            }
            //ページ変更と動作指定が重なると不安なので、トップレーンの処理を待つ
            @while topLaneFlag == 7 bl {
                @wait(0)
            }
            @wait(5)
            //中央に光を降らせる
            @anim[BUMPER_SWITCH_ANIM].show {
                .target(MEV_TOP_BUMPER_LEVEL)
                .buffer(ANIM_BUFFER_EVENT)
                .reverse(0)
            }
            @wait(4)

            //バンパーの移動
            topBumperPos = (topBumperPos + 1) % MAX_BUMPER_SWITCH

            //1
            temA = MEV_TOP_BUMPER_1
            V2_set(temB,
                [11, 9,13][topBumperPos],
                [ 8, 9,11][topBumperPos]
            )
            @ev.setPos [temA] .pos(temB, temC) 
            @ev.flash [temA] .rgbv(31, 31, 31, 31) .time(5)

            //
            temA = MEV_TOP_BUMPER_2
            V2_set(temB,
                [13,13,12][topBumperPos],
                [11, 9,12][topBumperPos]
            )
            @ev.setPos [temA] .pos(temB, temC) 
            @ev.flash [temA] .rgbv(31, 31, 31, 31) .time(5)

            temA = MEV_TOP_BUMPER_3
            V2_set(temB,
                [ 9,11,14][topBumperPos],
                [11,12,10][topBumperPos]
            )
            @ev.setPos [temA] .pos(temB, temC) 
            @ev.flash [temA] .rgbv(31, 31, 31, 31) .time(5)

            //一巡するとマルチプライヤーもゲット
            @if topBumperPos == 0 bl {
                pbAddScore(NUM_TYPE_MULTI, MULTI_TOP_BUMPER_SWITCH, 0)
                pbDisplay(DI_ST_NORMAL, __str("\c[2]マルチプライヤー +", MULTI_TOP_BUMPER_SWITCH))
            }

            @wait(4)
            endEventMode()

            //少し間をおいて通常状態に戻る
            @wait(30)
            @ev.setAction .self .freq(8) .skippable .act {
                .faceUp
            }

        //少し間を置く
        } .else bl {
            @se.play "dj_scratch1" .opt(100, 100, 50)
            @ev.flash .self .rgbv(31, 31, 31, 31) .time(5)
            @ev.setAction .self .freq(8) .skippable .act {
                .faceRight
            }
            @wait(5)
            @ev.setAction .self .freq(8) .skippable .act {
                .faceUp
            }
        }
    }
}

//--------------------------------
//スピナー
def {
    SPINNER_Y = 13
    SPINNER_ANGLE = 100
    SPINNER_MUL = 1
    SPINNER_MIN = 1 * UNIT_POS
    SPINNER_MAX = UNIT_LOOP / 4
    SPINNER_STEPUP = 5 * UNIT_POS
    SPINNER_STEP = 3
    SPINNER_MAXLEVEL = 2
    SPINNER_FREQ = UNIT_LOOP
}
mev[MEV_SPINNER] .pos(16, SPINNER_Y) .name("スピナー")
mep[1] .body(CHARSET_SPINNER, 0) .dir.up .anim.step .priority.low .parallel bl {
    //簡易判定
    @if `ROUGHLY_CHECK_BALL_HIGH bl {
        //a:hit id b:dot c:hit speed d:pattern
        pbBallToArea(temA, temB,
        GIM_LAYER_MID, self.id, SHARP_RECT, SPINNER_ANGLE, 0, -12, -8, 12, 8)
        @if temA >= 0 bl {
            //通過速度
            temC = min(abs(temB) * SPINNER_MUL, SPINNER_MAX)
            //速度差がある場合は更新する
            @if `temC > (spinnerSpeed + SPINNER_MIN) bl {
                //レベルアップ判定
                //既に回転していて、速度が一定以上だとレベルが上がる
                @if `spinnerLevel < SPINNER_MAXLEVEL && spinnerSpeed > 0 && temC > SPINNER_STEPUP bl {
                    spinnerLevel += 1
                    @se.play "voice_hohou" .opt(80, 100, 50)
                //速度がゼロの場合は清算して初期化する
                } .elif spinnerSpeed <= 0 {
                    spinnerLevel = 0
                }

                //勢いで効果音が変わる
                @if temC > SPINNER_STEPUP bl {
                    @se.play "Wind5" .opt(80, 100, 50)
                } .else bl {
                    @se.play "Wind3" .opt(80, 100, 50)
                }

                @ev.flash .self .rgbv(31, 31, 31, 31) .time(5)

                //回転開始
                spinnerSpeed = temC
                //グラフィックを変更する
                temD = spinnerLevel + 1
                @ev.setAction .self .freq(8) .act {}
                @ev.addAction .setBody(CHARSET_SPINNER, temD)
                @ev.addAction .face(DIR_FACE_RIGHT)
            }
            @wait(0)
        }
    }

    //回転
    //イベント中は止まる
    @if `!eventMode && spinnerSpeed > 0 bl {
        spinnerAngle += spinnerSpeed
        spinnerSpeed -= SPINNER_STEP

        //回転継続
        @if spinnerSpeed > 0 bl {
            //向きを更新する
            temD = (spinnerAngle % UNIT_LOOP) / (UNIT_LOOP / 4)
            @ev.setAction .self .freq(8) .act {}
            @ev.addAction .face(temD)
        //停止する
        } .else bl {
            //スコア
            temA = (spinnerAngle / SPINNER_FREQ) * BONUS_SPINNER * (spinnerLevel + 1)
            @if temA > 0 bl {
                pbAddScore(NUM_TYPE_BONUS, temA, 0)
            }

            //回転が止まる
            spinnerAngle = 0
            spinnerSpeed = 0
            //グラフィックを戻す
            temD = spinnerLevel
            @ev.flash .self .rgbv(31, 31, 31, 31) .time(5)
            @ev.setAction .self .freq(8) .act {}
            @ev.addAction .setBody(CHARSET_SPINNER, 0)
            @ev.addAction .face(temD)
        }
    }    
}

//--------------------------------
//中アウトレーン
def {
    MIDDLE_OUTLANE_COUNT = 3
}
mev[MEV_MIDDLE_OUTLANE] .pos(4, 13) .name("中アウトレーン")
mep[1] .body(CHARSET_LANE, 6) .dir.up .anim.step .priority.low .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_HIGH bl {
        @ev.abort
    }

    pbBallToArea(temA, unusedV,
    GIM_LAYER_MID, self.id, SHARP_CIRCLE, 0, 8, 12, 12, 0, 0)
    @if temA < 0 bl {
        @ev.abort
    }

    middleOutLaneCount += 1

    @ev.setAction .self .freq(8) .skippable .act {
        .faceRight
    }
    @ev.flash .self .rgbv(31, 31, 31, 31) .time (5)
    @se.play "register" .opt(100, 100, 50)

    //スコア
    pbAddScore(NUM_TYPE_BONUS, BONUS_MIDDLE_OUTLANE, 0)

    //3回通ると停止し、フリッパーが追加される
    @if `!(subFlipperFlag & SUBFLIPPER_BIT_LEFT) bl {
        @if middleOutLaneCount >= MIDDLE_OUTLANE_COUNT bl {
            cm_addLeftSubFlipper()

            middleOutLaneCount = 0
        }

    //シューターを起動するか、タイマーを戻す
    } .elif middleRolloverState == GIM_ST_HIDE bl {
        @if middleOutLaneCount >= MIDDLE_OUTLANE_COUNT bl {
            middleOutLaneCount = 0

            pbDisplay(DI_ST_NORMAL, __str("\c[2]スターライトⅢ召喚"))
            
            @se.play "Holy3" .opt(80, 100, 50)
            @ev.flash [MEV_MIDDLE_ROLLOVER] .rgbv(31,31,31, 31) .time(2)

            //起動
            middleRolloverState = GIM_ST_ACTIVATED
            middleRolloverCount = 0
        }
    //シューターの回数を初期化する
    } .elif middleRolloverState == GIM_ST_ACTIVATED bl {
        @if middleRolloverCount < MIDDLE_ROLLOVER_COUNT 0 bl {
            middleOutLaneCount = 0
            middleRolloverCount = 0

            @se.play "Holy3" .opt(80, 100, 50)
            @ev.flash [MEV_MIDDLE_ROLLOVER] .rgbv(31,31,31, 31) .time(2)
        }
    }

    //しばらく判定が消える
    @wait(10)
    @ev.setAction .self .freq(8) .skippable .act {
        .faceUp
    }
}

//--------------------------------
//スターライト3
def {
    MIDDLE_ROLLOVER_COUNT = 3
    MIDDLE_ROLLOVER_RAD = 12

    MIDDLE_ROLLOVER_ANIM_X = 9 * MAPTILE_SIZE
    MIDDLE_ROLLOVER_ANIM_Y = 20 * MAPTILE_SIZE

    ANIM_MIDDLE_ROLLOVER = 16
}

mev[MEV_MIDDLE_ROLLOVER] .pos(6, 16) .name("スターライト3")
mep[1] bl {}
mep[2] .body(CHARSET_TARGET_1, 5) .dir.down .anim.fixDir.step .priority.middle .cond(v[__id(middleRolloverState)] == GIM_ST_ACTIVATED) .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_MIDDLE bl {
        @continue
    }

    //判定
    pbBallToArea(temA, unusedV,
    GIM_LAYER_MID, self.id, SHARP_CIRCLE, 0, MIDDLE_ROLLOVER_RAD, 0, 0, 0, 0)
    @if temA >= 0 bl {
        //敵を全て吹っ飛ばす
        temE = 0
        @loop MAX_ENEMY .dst(idxA) bl {
            getEnemyPtr(ptrA, idxA)
            temA = v[ptrA + ME_STATE]
            //徘徊中で、HPが1以上の敵が対象
            @if `temA != EN_ST_ENABLE || v[ptrA + ME_HP] <= 0 bl {
                @continue
            }
            //撃破数カウント
            temE += 1
            //イベントID
            temB = MEV_ENEMY_1 + idxA
            //HPをゼロに
            v[ptrA + ME_HP] = 0
            //状態を変える
            changeEnemyState(ptrA, EN_ST_DEFEAT, -1)
            //イベントを設置しなおす
            resetEventPositionByVar(temB)
            //吹っ飛ぶ方向
            temD = [DIR_EV_DOWNLEFT, DIR_EV_DOWNRIGHT][rnd(0,1)]
            @ev.setAction [temB] .freq(8) .skippable .act {}
            @ev.addAction .beginThrough
            @ev.addAction .fixDir
            @ev.addAction .speed(SPEED_ACT_QUADRUPLE)
            @ev.addAction .move(temD, 20)
            @ev.addAction .setBody("", 0)
            @ev.flash [temB] .rgbv(0, 0, 0, 31) .time(4)
        }

        //一体でも撃破していた場合
        @if temE > 0 bl {
            //ボーナスは撃破数に比例する
            temB = temE * BONUS_MIDDLE_ROLLOVER
            pbAddScore(NUM_TYPE_BONUS, temB, 0)
            //カウンタ
            middleRolloverCount += 1
            //歩行アニメ
            @ev.setAction .self .freq(6) .act {
                .setBody("", 0)
                .pause
                .pause
                .setBody(CHARSET_TARGET_1, 6)
                .pauseAnim
                .faceUp
                .faceRight
                .faceDown
                .faceLeft
                .resumeAnim
                .setBody(CHARSET_TARGET_1, 5)
                .faceDown
            }
            //魔法アニメ
            V2_set(temA,
                MIDDLE_ROLLOVER_ANIM_X - cameraX,
                MIDDLE_ROLLOVER_ANIM_Y - cameraY,
            )
            @anim.show [ANIM_MIDDLE_ROLLOVER] {
                .pos(temA, temB)
                .buffer(ANIM_BUFFER_EFFECT)
                .reverse(0)
            }
            @wait(14)
        //空ぶり
        } .else bl {
            //一回転
            @ev.setAction .self .freq(6) .act {
                .turnRight
                .turnRight
                .turnRight
                .turnRight
            }
            @se.play "Evade1" .opt(80, 100, 50)
            @wait(5)
        }

        //指定回数叩くと消える
        @if middleRolloverCount >= MIDDLE_ROLLOVER_COUNT bl {
            //カウンタを初期化する
            middleOutLaneCount = 0

            //消滅演出
            @anim.show [UNDER_TARGET_ANIM] {
                .self
                .buffer(ANIM_BUFFER_EFFECT)
                .reverse(0)
            }

            middleRolloverState = GIM_ST_HIDE
            @ev.abort
        }
    }
}

//--------------------------------
//右レーン
//下から上のみ
def {
    RIGHT_LANE_COUNT = 3
    RIGHT_LANE_OX    = 8
    RIGHT_LANE_ANG   = -90
}
mev[MEV_RIGHT_LANE] .pos(16,9) .name("右レーン")
mep[1] .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_HIGH bl {
        @ev.abort
    }
    //判定
    pbBallToArea(temA, temB,
    GIM_LAYER_MID, self.id, SHARP_RECT, RIGHT_LANE_ANG, 0, -6 + RIGHT_LANE_OX, -12, 6 + RIGHT_LANE_OX, 12)//やや右寄り
    @if `temA < 0 || temB < 0 bl {
        @ev.abort
    }

    //看板ボーナス
    @if boardDir == DIR_FACE_RIGHT bl {
        cm_boardBonus()

    }
    //通常ボーナス
    pbAddScore(NUM_TYPE_BONUS, BONUS_RIGHT_LANE, 0)

    //通過回数カウント
    rightLaneCount += 1
    @se.play "Cursor1" .opt(80, 100, 50)

    //三回通すとサブフリッパーが追加される
    //もう三回通すとブライアンが追加される
    @if `!(subFlipperFlag & SUBFLIPPER_BIT_RIGHT) bl {
        @if rightLaneCount >= RIGHT_LANE_COUNT bl {
            cm_addRightSubFlipper()
            rightLaneCount = 0
        }
    } .elif brianState == GIM_ST_HIDE bl {
        @if rightLaneCount >= RIGHT_LANE_COUNT bl {
            //カウンタを初期化
            rightLaneCount = 0
            //起動
            brianState = GIM_ST_ACTIVATED
            brianCount = 0
            @se.play "voice_ieeei2" .opt(90, 100, 50)
            @ev.flash [MEV_BRIAN] .rgbv(31, 31, 31, 31) .time(5)
            pbDisplay(DI_ST_NORMAL, __str("\c[2]ブライアン出動"))
            //動作指定
            @ev.setPos [MEV_BRIAN] .pos(BRIAN_SX, BRIAN_SY)
        }
    //カウンタを初期化する
    } .elif brianState == GIM_ST_ACTIVATED bl {
        @if brianCount < BRIAN_COUNT bl {
            brianCount = 0

            @se.play "voice_ieeei2" .opt(90, 100, 50)
            @ev.flash [MEV_BRIAN] .rgbv(31, 31, 31, 31) .time(5)
        }
    }
    @wait(5)
}

//--------------------------------
//ブライアン
//開始時にも起動する
def {
    BRIAN_COUNT = 3
    BRIAN_SX    = 16
    BRIAN_SY    = 10
    BRIAN_X     = 7
    BRIAN_Y     = 17
    BRIAN_RAD   = 8
    BRIAN_FRI   = 900
    BRIAN_REF   = 300
    BRIAN_VEL   = 1 * UNIT_POS / 2
}
mev[MEV_BRIAN] .pos(BRIAN_X, BRIAN_Y) .name("ブライアン")
mep[1] bl {}
mep[2] .body(CHARSET_TARGET_1, 4) .dir.down .anim.fixDir.step .priority.middle .cond(v[__id(brianState)] == GIM_ST_ACTIVATED) .parallel bl {
    //登場
    V2_set(temA,
        BRIAN_X - ev[self.id].x,
        BRIAN_Y - ev[self.id].y
    )
    @ev.setAction [MEV_BRIAN] .freq(8) .skippable .act {}
    @ev.addAction .beginThrough
    @ev.addAction .faceRight
    @ev.addAction .speed(SPEED_ACT_HALF)
    @ev.addAction .jump(temA, temB)
    @ev.addAction .speed(SPEED_ACT_QUARTER)
    @ev.addAction .faceDown

    //ボーナスゲームから出た直後は長めに待つ
    @if sceneState == SC_ST_EXIT_BONUSSTAGE bl {
        @wait(20)
    } .else bl {
        @wait(10)
    }

    //繰り返し移動
    @ev.setAction [MEV_BRIAN] .freq(8) .skippable .repeat .act {
        .beginThrough
        .moveRight
        .moveRight
        .moveRight
        .pause
        .moveLeft
        .moveLeft
        .moveLeft
        .pause
    }

    @loop bl {
        @wait(0)
        //簡易判定
        @if `!ROUGHLY_CHECK_BALL_MIDDLE bl {
            @continue
        }
        //判定
        pbUpdateBumper(temA, unusedV,
        GIM_LAYER_MID, BRIAN_FRI, BRIAN_REF, BRIAN_VEL,
        self.id, SHARP_CIRCLE, BRIAN_RAD, 0, 0, 0, 0)
        @if temA >= 0 bl {
            //カウンタ
            brianCount += 1
            //パワーアップ中は一撃で吹っ飛ぶ
            @if powerupTimer > 0 bl {
                brianCount = BRIAN_COUNT
                @se.play "voice_atui" .opt(90, 90, 50)
            }
            //吹っ飛ぶ
            @if brianCount >= BRIAN_COUNT bl {
                //スコア
                pbAddScore(NUM_TYPE_BONUS, BONUS_BRIAN_DEFEAT, 0)
                //カウンタを初期化
                rightLaneCount = 0

                @se.play "hit_db" .opt(100, 100, 50)
                @ev.flash .self .rgbv(31, 31, 31, 31) .time(5)

                //吹っ飛ぶ
                resetEventPositionByVar(MEV_BRIAN)
                @ev.setAction .self .freq(8) .skippable .act {}
                @ev.addAction .beginThrough
                @ev.addAction .fixDir
                @ev.addAction .speed(SPEED_ACT_QUADRUPLE)
                @ev.addAction .move(DIR_EV_UPLEFT, 20)
                @wait(5)            
                
                brianState = GIM_ST_HIDE
                @ev.abort
            //ダメージ
            } .else bl {
                //スコア
                pbAddScore(NUM_TYPE_BONUS, BONUS_BRIAN, 0)

                @se.play "flipper2" .opt(100, 100, 50)
                @se.play "bell1" .opt(70, 120, 50)
                @ev.flash .self .rgbv(31, 31, 31, 31) .time(4)
                @wait(1)
            }
        }
    }
}

//--------------------------------
//中カーブライト
def {
    MIDDLE_CURVE_NUM   = 2
    MIDDLE_CURVE_TIMER = 60
}
mev[MEV_MIDDLE_CURVE_1] .pos(13, 13) .name("中カーブ1")
mep[1] .body(CHARSET_LANE, 5) .anim.step .priority.low .dir(.up) bl {}
mev[MEV_MIDDLE_CURVE_2] .pos(15, 9) .name("中カーブ2")
mep[1] .body(CHARSET_LANE, 5) .anim.step .priority.low .dir(.up) .parallel bl {
    //時間が経つと戻る
    @if `middleCurveFlag != 0 && middleCurveTimer > 0 bl {
        middleCurveTimer -= 1
        @if middleCurveTimer <= 0 bl {
            //フラグ初期化
            middleCurveFlag = 0
            ///レーンの状態を戻す
            @loop MIDDLE_CURVE_NUM .dst(idxA) bl {
                temB = MEV_MIDDLE_CURVE_1 + idxA
                @ev[temB].setAction .freq(8) .skippable .act {
                    .faceUp
                }
            }
        }
    }

    //簡易判定
    @if `ROUGHLY_CHECK_BALL_HIGH bl {
        //２つのレーンの判定を１つのイベントで行う
        //a:index b:event id c:bit d:hit id
        @loop MIDDLE_CURVE_NUM .dst(idxA) bl {
            //スイッチID
            temC = 1 << idxA
            @if `!(middleCurveFlag & temC) bl {
                //イベントID
                temB = MEV_MIDDLE_CURVE_1 + idxA
                //判定
                pbBallToArea(temD, unusedV,
                GIM_LAYER_MID, temB, SHARP_RECT, 0, 0, -8, -8, 8, 8)
                @if temD >= 0 bl {
                    //フラグ
                    middleCurveFlag |= temC
                    //起動する
                    @ev[temB].setAction .freq(8) .skippable .act {
                        .faceRight
                    }
                    //全て揃った
                    // bit 11
                    @if middleCurveFlag == 3 bl {
                        //スコア
                        pbAddScore(NUM_TYPE_BONUS, BONUS_MIDDLE_CURVE, 0)
                        //ファルコンミッション
                        temA = FALCON_AREA_CENTER_CURVE
                        cm_falconMission()
                        //フラグ初期化
                        middleCurveFlag = 0
                        middleCurveTimer = 0
                        //しばらくした後、レーンの状態を戻す
                        @wait(2)
                        @loop MIDDLE_CURVE_NUM .dst(idxB) bl {
                            temB = MEV_MIDDLE_CURVE_1 + idxB
                            @ev[temB].setAction .freq(8) .skippable .act {
                                .faceUp
                            }
                        }
                        @se.play "Chime2" .opt(80, 120, 50)
                        @break
                    } .else bl {
                        middleCurveTimer = MIDDLE_CURVE_TIMER
                        @se.play "Cursor2" .opt(60, 120, 50)
                    }
                }
            }
        }
    }
}

//--------------------------------
//左レーン
def {
    LEFT_LANE_COUNT = 3
    LEFT_LANE_ANIM  = 8
    LEFT_LANE_ANG   = -60
}
mev[MEV_LEFT_LANE] .pos(2, 5) .name("左レーン")
mep[1] .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_HIGH bl {
        @ev.abort
    }
    //判定
    //上45度
    pbBallToArea(temD, temE,
    GIM_LAYER_MID, self.id, SHARP_RECT, LEFT_LANE_ANG, 0, -12, -12, 12, 12)
    @if `temD < 0 || temE < 0 bl {
        @ev.abort
    }

    //看板ボーナス
    @if boardDir == DIR_FACE_LEFT bl {
        cm_boardBonus()
    }
    //通常ボーナス
    pbAddScore(NUM_TYPE_BONUS, BONUS_LEFT_LANE, 0)

    //爆発
    @scr.shake .once(3) .value(2, 7)
    @anim.show [LEFT_LANE_ANIM] {
        .self
        .buffer(ANIM_BUFFER_EFFECT)
        .reverse(0)
    }

    //パワーアップ中はカウントもされず、ファルコンのイベントは発生しない
    @if powerupTimer <= 0 bl {
        //通過回数カウント
        leftLaneCount += 1

        //三回入れるとファルコンが現れる。既に現れている場合はタイマーが戻る
        @if falconState == GIM_ST_HIDE bl {
            @if leftLaneCount >= LEFT_LANE_COUNT bl {
                leftLaneCount = 0
                falconState = GIM_ST_EVENT
                falconTimer = FALCON_SECOND * UNIT_FPS
                falconArea = rnd(0, FALCON_AREA_SIZE - 1)
                falconFlag = TRUE

                pbDisplay(DI_ST_NORMAL, __str("\c[2]スマートミッション！ (", FALCON_SECOND,"s)"))

                @ev.flash [MEV_FALCON] .rgbv(31, 31, 31, 31) .time(5)
                @se.play "Holy5" .opt(100, 130, 50)
            }
        //時間を少し回復させる
        } .elif falconState == GIM_ST_ACTIVATED bl {
            @if falconTimer > 0 bl {
                leftLaneCount = 0
                falconTimer = min(falconTimer + FALCON_SECOND_ADD * UNIT_FPS, FALCON_SECOND * UNIT_FPS)

                @ev.flash [MEV_FALCON] .rgbv(31, 31, 31, 31) .time(5)
                @se.play "Holy5" .opt(100, 130, 50)
            }
        }
    }

    @wait(5)
}

//--------------------------------
//ファルコン
def {
    FALCON_X      = 2
    FALCON_Y      = 6
    FALCON_SECOND = 30
    FALCON_SECOND_ADD = 10
    FALCON_COUNT  = 3

    FALCON_AREA_TOP_LANE = 0
    FALCON_AREA_CENTER_CURVE
    FALCON_AREA_LEFT_ENEMY
    FALCON_AREA_RIGHT_ENEMY
    FALCON_AREA_UNDER_REEL
    FALCON_AREA_SIZE
}
mev[MEV_FALCON] .pos(FALCON_X, FALCON_Y) .name("ファルコン")
mep[1] bl {}
mep[2] .body(CHARSET_EVENT_1, 3) .dir.down .anim.step .priority.high .cond(v[__id(falconState)] == GIM_ST_EVENT) .parallel bl {
    //登場する
    @ev.setPos [MEV_FALCON] .pos(FALCON_X, FALCON_Y)
    @ev.setAction .self .freq(8) .skippable .act {
        .beginThrough
        .faceDown
        .beginJump
        .endJump
        .pause
        .pause
        .beginJump
        .moveRight
        .moveRight
        .moveRight
        .moveDown
        .moveDown
        .endJump
        .beginJump
        .moveLeft
        .moveLeft
        .moveDown
        .moveDown
        .moveDown
        .endJump
        .beginJump
        .moveLeft
        .moveLeft
        .moveLeft
        .moveDown
        .endJump
    }

    @wait(18)
    falconState = GIM_ST_ACTIVATED
}

mep[3] .body(CHARSET_EVENT_1, 3) .dir.down .anim.step .priority.middle .cond(v[__id(falconState)] == GIM_ST_ACTIVATED) .parallel bl {
    //カウントダウンと点滅
    countDownEvent(falconTimer, MEV_FALCON)
    @if falconTimer <= 0 bl {
        @anim.show [UNDER_TARGET_ANIM] {
            .self
            .buffer(ANIM_BUFFER_EFFECT)
            .reverse(0)
        }
        falconState = GIM_ST_HIDE
        @ev.abort
    }
    //移動する
    @if falconFlag == TRUE bl {
        @if falconSuccess > 0 bl {
            @wait(10)
        }

        //三回成功すると玉の強化フラグが立つ
        @if falconSuccess >= FALCON_COUNT bl {
            //成功回数初期化
            falconSuccess = 0

            //カプセル前へ移動
            @ev.setPos .self .pos(7, 10)
            @ev.setAction .self .freq(6) .skippable .act {
                .beginThrough
                .faceUp
                .moveUp
            }
            @ev.flash [MEV_FALCON] .rgbv(0, 0, 0, 31) .time(5)
            @se.play "bukuu1" .opt(90, 100, 50)

            @wait(8)

            //マルチプライヤー
            pbAddScore(NUM_TYPE_MULTI, MULTI_FALCON, 0)
            pbDisplay(DI_ST_ZOOM, __str("\c[2]マルチプライヤー +", MULTI_FALCON))

            //強化フラグ
            @if `!(iconFlag & ICON_BIT_POWERUP) bl {
                iconOn(ICON_BIT_POWERUP)
                cm_updateCenterHole()
                pbDisplay(DI_ST_ZOOM, __str("\c[2]パワーアップカプセル解禁！"))
            }

            //前を向く
            @ev.setAction .self .freq(6) .skippable .act {
                .turnRight
                .turnRight
            }
            @scr.flash .once(2) .rgbv(31, 31, 31, 24)
            @se.play "Holy2" .opt(100, 100, 50)

            //消滅
            @wait(10)
            @anim.show [UNDER_TARGET_ANIM] {
                .self
                .buffer(ANIM_BUFFER_EFFECT)
                .reverse(0)
            }

            //カウンタを初期化する
            leftLaneCount = 0

            falconState = GIM_ST_HIDE
            @ev.abort

        } .else bl {
            //被らないように選択
            temA = rnd(1, FALCON_AREA_SIZE - 1)
            falconArea = (falconArea + temA) % FALCON_AREA_SIZE
            falconFlag = FALSE
            falconTimer = FALCON_SECOND * UNIT_FPS

            //場所移動
            V2_set(temA,
                [11, 12,  3, 15,  8][falconArea],
                [ 5, 13, 17, 17, 21][falconArea]
            )
            temC = [2, 1, 3, 1, 2][falconArea]
            @ev.setPos .self .pos(temA, temB)
            @ev.setAction .self .freq(8) .skippable .act {
                .faceDown
                .beginJump
                .endJump
            }
            @ev.addAction .face(temC)
            @ev.flash [MEV_FALCON] .rgbv(0, 0, 0, 31) .time(5)
            @se.play "bukuu1" .opt(90, 100, 50)
        }
    }
}
//--------------------------------
//森崎君
def {
    ROOFTOP_KEEPER_X    = 5
    ROOFTOP_KEEPER_Y    = 6
    ROOFTOP_KEEPER_VEL1 = 5 * UNIT_POS
    ROOFTOP_KEEPER_ANG1 = -60 * UNIT_ANGLE
    ROOFTOP_KEEPER_VEL2 = 2 * UNIT_POS
    ROOFTOP_KEEPER_ANG2 = 120 * UNIT_ANGLE
    ROOFTOP_KEEPER_HP   = 2
}
mev[MEV_ROOFTOP_KEEPER] .pos(ROOFTOP_KEEPER_X, ROOFTOP_KEEPER_Y) .name("森崎君")
mep[1] .body(CHARSET_TARGET_1, 0) .dir.right .anim.fixDir.step .priority.high .parallel bl {
    @if rooftopKeeperHp >= ROOFTOP_KEEPER_HP bl {
        @ev.abort
    }
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_HIGH bl {
        @ev.abort
    }
    //判定
    pbBallToArea(temA, unusedV,
    GIM_LAYER_HI, self.id, SHARP_RECT, 0, 0, -8, -24, 24, 8)
    @if temA < 0 bl {
        @ev.abort
    }
    //ダメージ
    rooftopKeeperHp += 1
    //固定した玉ID
    rooftopKeeperCatchId = temA
    //球を移動させる
    pbBallFunction(BA_FUNC_SET_POS, rooftopKeeperCatchId, self.id, GIM_LAYER_HI, 8, -8)
    pbBallFunction(BA_FUNC_LOCK,    rooftopKeeperCatchId, 0, 0, 0, 0)
    //受け止める
    @se.play "Thunder3" .opt(100, 100, 50)
    @se.play "Blow6" .opt(100, 100, 50)
    //イベントを揺らす
    @loop 36 bl {
        @ev.setAction .self .freq(8) .skippable .act {
            .beginThrough
            .moveRandom
        }
        @wait .frame(1)
        @ev.setPos .self .pos(ROOFTOP_KEEPER_X, ROOFTOP_KEEPER_Y) 
    }
    //撃破
    @if rooftopKeeperHp >= ROOFTOP_KEEPER_HP bl {
            //スコア
            pbAddScore(NUM_TYPE_BONUS, BONUS_ROOFTOP_KEEPER_DEFEAT, 0)

            //ジャンプスイッチを起動する
            @if jumpSwitchrState == GIM_ST_HIDE bl {
                jumpSwitchrState = GIM_ST_ACTIVATED
                pbDisplay(DI_ST_NORMAL, __str("\c[2]ジャンプスイッチが出現！ $v$t:食う"))
            }

            //球を解放する
            pbBallFunction(BA_FUNC_UNLOCK,  rooftopKeeperCatchId, 0, 0, 0, 0)
            pbBallFunction(BA_FUNC_SET_VEL, rooftopKeeperCatchId, ROOFTOP_KEEPER_VEL2, ROOFTOP_KEEPER_ANG2, 0, 0)
            rooftopKeeperCatchId = -1
            //吹っ飛ぶ
            @ev.setAction .self .freq(8) .skippable .act {
                .beginThrough
                .faceLeft
                .speedUp
                .moveLowerLeft
                .moveLowerLeft
                .moveLowerLeft
                .speedDown
                .faceUp
            }
            @se.play "Explosion3" .opt(100, 100, 50)
            @se.play "cheers" .opt(100, 100, 50)
            @ev.flash .self .rgbv(31, 31, 31, 31) .time(5)
            @wait(8)
    //弾き返す
    } .else bl {
        @se.play "Sword2" .opt(80, 100, 50)
        @ev.flash .self .rgbv(31, 31, 31, 31) .time(2)
        @wait(5)
        //射出
        pbBallFunction(BA_FUNC_UNLOCK,  rooftopKeeperCatchId, 0, 0, 0, 0)
        pbBallFunction(BA_FUNC_SET_VEL, rooftopKeeperCatchId, ROOFTOP_KEEPER_VEL1, ROOFTOP_KEEPER_ANG1, 0, 0)
        rooftopKeeperCatchId = -1
        //蹴る
        @ev.setAction .self .freq(8) .skippable .act {
            .faceDown
            .pause
            .pause
            .faceRight
        }
        @se.play "Blow3" .opt(90, 100, 50)
        @wait(4)
    }
}

//--------------------------------
//ジャンプスイッチ
def {
    JUMP_SWITCH_X   = 12
    JUMP_SWITCH_Y   = 3
    JUMP_SWITCH_RAD = 8

    JUMP_SWITCH_INPUT = 8
    JUMP_SWITCH_VEL   = 6 * UNIT_POS
    JUMP_SWITCH_ANG   = -150 * UNIT_ANGLE
}
mev[MEV_JUMP_SWITCH] .pos(JUMP_SWITCH_X, JUMP_SWITCH_Y) .name("ジャンプスイッチ")
mep[1] bl {}
mep[2] .body(CHARSET_EVENT_1, 2) .dir.up .anim.fixDir.step .priority.high .cond(v[__id(jumpSwitchrState)] == GIM_ST_ACTIVATED) .parallel bl {
    //イベント中は判定しない
    @if `eventMode bl {
        @ev.abort
    }

    //フリッパーのキーが押された瞬間に判定する
    @if `leftFlipperInput != 1 && rightFlipperInput != 1 bl {
        @ev.abort
    }

    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_HIGH bl {
        @ev.abort
    }

    //判定
    pbBallToArea(temA, unusedV,
    GIM_LAYER_HI, self.id, SHARP_RECT, 0, 0, -16, -12, 16, 12)
    @if temA < 0 bl {
        @ev.abort
    }

    //玉ID
    jumpSwitchrCatchId = temA
    //スコア
    pbAddScore(NUM_TYPE_BONUS, BONUS_JUMP_SWITCH, 0)
    //玉を隠す
    pbBallFunction(BA_FUNC_HIDE, jumpSwitchrCatchId, 0, 0, 0, 0)
    //イベント開始
    @wait(0)
    startEventMode()
    //暗転
    @scr.tint .rgbs(200, 200, 200, 0) .time(0)
    @scr.tint .rgbs(100, 100, 100, 0) .time(1)
    //右から来る
    @ev.setPos .self .pos(JUMP_SWITCH_X, JUMP_SWITCH_Y)
    @ev.setAction .self .freq(8) .skippable .act {
        .beginThrough
        .faceLeft
        .pauseAnim
        .speedDown
        .speedDown
        .moveLeft
    }
    @loop 4 .dst(idxA) bl {
        idxA = 100 - idxA * 20
        @se.play "voice_musha" .opt(idxA, 80, 50)
        @se.play "voice_musha" .opt(idxA, 80, 50)
        @wait(0)
        idxA -= 20
        @se.play "voice_musha" .opt(idxA, 80, 100)
        @wait(0)
        idxA -= 20
        @se.play "voice_musha" .opt(idxA, 80, 0)
        @wait .frame(16)
    }
    @scr.tint .rgbs(100, 100, 100, 100) .time(0)
    @se.play "bukuu1" .opt(100, 140, 50)
    @ev.setAction .self .freq(8) .skippable .act {
        .speedUp
        .speedUp
        .speedUp
        .speedUp
        .speedUp
        .speedUp
        .moveLeft
        .moveLeft
        .moveLeft
        .moveLeft
        .moveLeft
        .moveLowerLeft
        .moveLowerLeft
        .moveLowerLeft
        .speedDown
        .speedDown
        .speedDown
        .speedDown
        .speedDown
        .speedDown
        .faceDown
    }
    @wait(2)

    @ev.flash [MEV_HELEN] .rgbv(31, 31, 31, 31) .time(5)
    @se.play "Cursor1" .opt(100, 100, 50)
    @wait(4)

    //矢をつがえる
    @ev[MEV_HELEN].setAction .freq(6) .act {
        .pauseAnim
        .setBody(CHARSET_HOLE, 5)
        .faceUp
        .faceRight
    }
    @wait(4)

    //矢ではなく球が放たれる
    pbBallFunction(BA_FUNC_UNLOCK, jumpSwitchrCatchId, 0, 0, 0, 0)
    pbBallFunction(BA_FUNC_SET_POS, jumpSwitchrCatchId, MEV_HELEN, GIM_LAYER_HI, 0, -8)
    pbBallFunction(BA_FUNC_SET_VEL, jumpSwitchrCatchId, JUMP_SWITCH_VEL, JUMP_SWITCH_ANG, 0, 0)
    jumpSwitchrCatchId = -1
    endEventMode()

    //矢を放つ動作
    @ev[MEV_HELEN].setAction .freq(6) .act {
        .faceDown
        .pause
        .faceLeft
        .resumeAnim
        .setBody(CHARSET_HOLE, 4)
        .faceUp
    }

    //カウント
    nasuHp += 1

    //命中
    @if nasuHp == NASU_HP bl {
        //エフェクト
        @anim.show [CENTER_HOLE_ANIM_BOW] {
            .target(MEV_HELEN)
            .buffer(ANIM_BUFFER_EFFECT)
            .reverse(0)
        }
        @wait(2)

        //スコア
        pbAddScore(NUM_TYPE_MULTI, MULTI_LEADER, 0)
        
        iconOn(ICON_BIT_NASU)
        pbDisplay(DI_ST_ZOOM, __str("\c[2]パワードラゴナスを撃破！"))
        //演出
        @se.play "hit_db" .opt(100, 100, 50)
        @ev.flash [MEV_NASU] .rgbv(31, 31, 31, 31) .time(5)
        //ヒットストップ
        hitStopTimer = 12
        @wait .frame(12)
        //怯む
        @ev[MEV_NASU].setAction .freq(8) .skippable .act {
            .beginThrough
            .faceRight
            .beginJump
            .moveDown
            .endJump
            .faceDown
        }
        //通過するまで待つ
        @wait(20)

        //WORLDストッパーも起動する
        @if worldState == GIM_ST_HIDE bl {
            worldState = GIM_ST_ACTIVATED
            worldTimer = 0
            pbDisplay(DI_ST_ZOOM, __str("\c[2]WORLDストッパーが出現  $v$t:頭突き"))
        }
    //回避
    } .elif nasuHp < NASU_HP bl {
        //スコア
        pbAddScore(NUM_TYPE_BONUS, BONUS_NASU_DAMAGE, 0)

        @se.play "Bow1" .opt(100, 100, 50)
        @wait(1)
        @se.play "Evade1" .opt(100, 100, 50)
        @ev[MEV_NASU].setAction .freq(8) .skippable .act {
            .beginThrough
            .speedUp
            .moveDown
            .speedDown
            .moveUp
        }
        @wait(5)
    //放つだけ
    } .else bl {
        @se.play "Bow1" .opt(100, 100, 50)
        @wait(5)
    }

    //イベントを戻す
    @ev.setPos .self .pos(JUMP_SWITCH_X, JUMP_SWITCH_Y)
    @ev.setAction .self .freq(8) .skippable .act {
        .faceUp
        .resumeAnim
    }
    @wait(1)
}

//--------------------------------
//WORLDストッパー
//右に入れると下に、離すと上に
def {
    WORLD_X     = 10
    WORLD_Y     = 1
    WORLD_OX    = 0
    WORLD_OY    = -8
    WORLD_RAD   = 8
    WORLD_FRI   = 900
    WORLD_REF   = 200
    WORLD_VEL   = 1 * UNIT_POS / 2
    WORLD_TIMER = 6 * 4
}
mev[MEV_WORLD] .pos(WORLD_X, WORLD_Y) .name("WORLD")
mep[1] bl {}
mep .body(CHARSET_TARGET_1, 3) .dir.down .anim.fixDir.step .priority.middle .cond(v[__id(worldState)] == GIM_ST_ACTIVATED) .action(.speed(4)) .id(2) .parallel bl {
    //上下に移動する
    @if `!eventMode bl {
        @if `leftFlipperInput > 0 || rightFlipperInput > 0 bl {
            @if `ev[self.id].y < WORLD_Y + 1 bl {
                @ev.setAction .self .freq(8) .skippable .act {
                    .beginThrough
                    .moveDown
                }
            }
        } .else bl {
            @if `ev[self.id].y > WORLD_Y bl {
                @ev.setAction .self .freq(8) .skippable .act {
                    .beginThrough
                    .moveUp
                }
            }
        }
    }
    //判定
    //連続ヒットを防ぐ
    @if worldTimer > 0 bl {
        worldTimer -= 1
    } .else bl {
        @if `ROUGHLY_CHECK_BALL_HIGH bl {
            pbUpdateBumper(temA, unusedV,
            GIM_LAYER_MID, WORLD_FRI, WORLD_REF, WORLD_VEL,
            self.id, SHARP_CIRCLE, WORLD_RAD, WORLD_OX, WORLD_OY, 0, 0)
            @if temA >= 0 bl {            
                //カウンタ
                worldTimer = WORLD_TIMER
                //演出
                @se.play "Jump2" .opt(100, 100, 50)
                @ev.flash .self .rgbv(31, 31, 31, 31) .time(4)
            }
        }
    }
}

//--------------------------------
//ラナ
//サブフリッパーを追加する演出に使用する
def {
    SUBFLIPPER_EVENT_X = 16
    SUBFLIPPER_EVENT_Y = 11
}
mev[MEV_SUBFLIPPER_EVENT] .pos(SUBFLIPPER_EVENT_X, SUBFLIPPER_EVENT_Y) .name("サブフリッパー演出用")
mep[1] .body(CHARSET_EVENT_1, 1) .dir.up .priority.middle bl {}
