//--------------------------------
//スリングショット
def {
    SLINGSHOT_NUM = 2
    SLINGSHOT_Y = 24
    SLINGSHOT_FRI = 900
    SLINGSHOT_REF = 500
    SLINGSHOT_POW = 2 * UNIT_POS
    SLINGSHOT_COUNT = 6
}
mev[MEV_LEFT_SLINGSHOT] .pos( 4, SLINGSHOT_Y) .name("左スリングショット")
mep[1] .body(CHARSET_SLINGSHOT, 0) .dir.up .anim.fixDir .priority.middle bl {}
mev[MEV_RIGHT_SLINGSHOT] .pos(14, SLINGSHOT_Y) .name("右スリングショット")
mep[1] .body(CHARSET_SLINGSHOT, 1) .dir.up .anim.fixDir .priority.middle .parallel bl {
    //左右両方の判定をイベント一つで行う
    //a:index b:event id c;sgn d:hit id
    @loop SLINGSHOT_NUM .dst(idxA) bl {
        temB = MEV_LEFT_SLINGSHOT + idxA
        temC = idxA <= 0 ? 1 : -1
        //簡易判定
        @if `ROUGHLY_CHECK_BALL_LOW bl {
            pbUpdateBumper(temD, unusedV,
            GIM_LAYER_MID, SLINGSHOT_FRI, SLINGSHOT_REF, SLINGSHOT_POW,
            temB, SHARP_SEGMENT_ONLY, 2, -4 * temC, -24, 22 * temC, 16)
            @if temD >= 0 bl {
                //スコア
                pbAddScore(NUM_TYPE_BONUS, BONUS_SLINGSHOT, 0)

                //蹴り動作
                @se.play "Open1" .opt(80, 130, 50)
                @se.play "bell1" .opt(90, 100, 50)
                @ev.flash [temB] .rgbv(31, 31, 31, 31) .time(5)
                @ev.setAction[temB] .freq(8) .skippable {
                    .faceRight
                    .pause
                    .pause
                    .faceUp
                }

                //指定回数ごとにユニークターゲットを出現させる
                slingshotCount += 1
                @if `!(slingshotCount % SLINGSHOT_COUNT) bl {
                    @if underTargetState == UNDER_TARGET_ST_NONE bl {
                        underTargetState = idxA ? UNDER_TARGET_ST_RIGHT : UNDER_TARGET_ST_LEFT
                        underTargetTimer = UNDER_TARGET_SECOND * UNIT_FPS
                    }
                }

                //連続で当たらないように間を設ける
                @wait(1)
                @break
            }
        }
    }
}

//--------------------------------
//スリングショットユニークターゲット
def {
    UNDER_TARGET_ST_NONE = 0
    UNDER_TARGET_ST_LEFT
    UNDER_TARGET_ST_RIGHT

    UNDER_TARGET_ANIM = 11
    UNDER_TARGET_SECOND = 5
}
mev[MEV_UNDER_TARGET] .pos(14, 0) .name("下ユニークターゲット")
mep[1] .body(CHARSET_SLINGSHOT, 3) .dir.left .anim.fixDir.step .priority.middle .parallel bl {
    @if underTargetState <= UNDER_TARGET_ST_NONE bl {
        @ev.abort
    }

    //左:ロングソード
    @if underTargetState == UNDER_TARGET_ST_LEFT bl {
        //相対位置
        V2_set(temB, 7 - 5, 19 - 23)
        //跳ねる
        @ev.setPos .self .pos(5, 23)
        @ev.setAction .self .freq(8) .skippable {
            .setBody(CHARSET_SLINGSHOT, 2)
            .beginThrough
            .faceDown
        }
        @ev.addAction .jump(temB, temC)
        @ev.addAction .faceRight

        @se.play "Sword2" .opt(100, 100, 50)
        @ev.flash .self .rgbv(31, 31, 31, 31) .time(2)
        @wait(6)
    //右:寝る前さん
    } .else bl {
        @ev.setPos .self .pos(13, 23)
        @ev.setAction .self .freq(8) .skippable {
            .setBody(CHARSET_SLINGSHOT, 3)
            .beginThrough
            .faceUp
        }
        @se.play "Holy1" .opt(80, 100, 50)
        @ev.flash .self .rgbv(0, 0, 0, 31) .time(5)
        @wait(4)
        @ev.setPos .self .pos(11, 19)
        @se.play "Attack2" .opt (100, 120, 50)
        @ev.flash .self .rgbv(0, 0, 0, 31) .time(2)
        @wait(2)
    }

    //判定開始
    @while underTargetTimer > 0 bl {
        @wait(0)
        //カウントダウンと点滅
        countDownEvent(underTargetTimer, MEV_UNDER_TARGET)
        //簡易判定
        @if `ROUGHLY_CHECK_BALL_MIDDLE bl {
            //判定
            pbBallToArea(temA, unusedV,
            GIM_LAYER_MID, self.id, SHARP_CIRCLE, 0, 16, 0, 0, 0, 0)
            @if temA >= 0 bl {
                //スコア
                pbAddScore(NUM_TYPE_BONUS, BONUS_UNDER_TARGET, 0)

                //動作
                @if underTargetState == UNDER_TARGET_ST_LEFT bl {
                    @ev.setAction .self .freq(6) .skippable .act {
                        .faceLeft
                        .faceUp
                    }
                } .else bl {
                    @ev.setAction .self .freq(6) .skippable .act {
                        .faceRight
                    }
                }

                @se.play "Item1" .opt(100, 100, 50)
                @ev.flash .self .rgbv(31, 31, 31, 31) .time(2)
                @wait(10)
                @break
            }
        }
    }

    //戦闘アニメが終わった後、透明になって初期位置に戻る
    @anim.show [UNDER_TARGET_ANIM] {
        .self
        .buffer(ANIM_BUFFER_EFFECT)
        .reverse(0)
    }
    @ev.setAction .self .freq(8) .skippable {
        .setBody(CHARSET_SLINGSHOT, 3)
        .faceLeft
    }
    @wait(10)
    @ev.setPos .self .pos(14, 0)
    //状態を戻す
    underTargetState = UNDER_TARGET_ST_NONE
}

//--------------------------------
//下レーン
def {
    UNDER_LANE_NUM = 4
    UNDER_LANE_Y   = 23
    UNDER_LANE_HITBIT = 1 << 5
    UNDER_LANE_BITMASK = 15
}
mev[MEV_UNDER_LANE_1] .pos( 2, UNDER_LANE_Y) .name("下レーン1")
mep[1] .body(CHARSET_LANE, 0) .anim.fixDir.step .priority.middle .dir(.up) bl {}
mev[MEV_UNDER_LANE_2] .pos( 3, UNDER_LANE_Y) .name("下レーン2")
mep[1] .body(CHARSET_LANE, 0) .anim.fixDir.step .priority.middle .dir(.right) bl {}
mev[MEV_UNDER_LANE_3] .pos(15, UNDER_LANE_Y) .name("下レーン3")
mep[1] .body(CHARSET_LANE, 0) .anim.fixDir.step .priority.middle .dir(.down) bl {}
mev[MEV_UNDER_LANE_4] .pos(16, UNDER_LANE_Y) .name("下レーン4")
mep[1] .body(CHARSET_LANE, 0) .anim.fixDir.step .priority.middle .dir(.left) .parallel bl {
    //４つのレーンの判定を１つのイベントで行う
    //a:index b:event id c:bit d:hit id e:hit flag
    temE = FALSE
    //簡易判定
    @if `ROUGHLY_CHECK_BALL_LOW bl {
        @loop UNDER_LANE_NUM .dst(temA) bl {
            //イベントID
            temB = MEV_UNDER_LANE_1 + temA
            //スイッチID
            temC = 1 << temA
            //判定
            pbBallToArea(temD, unusedV,
            GIM_LAYER_MID, temB, SHARP_RECT, 0, 0, -8, -8, 8, 8)
            @if temD >= 0 bl {
                //接触フラグ
                temE = TRUE
                //点灯させる
                @if `!(underLaneFlag & temC) bl {
                    //スコア
                    pbAddScore(NUM_TYPE_BONUS, BONUS_UNDER_LANE, 0)
                    //フラグ
                    underLaneFlag |= temC
                    //起動する
                    @ev.setAction [temB] .freq(8) .unskippable .act {
                        .setBody(CHARSET_LANE, 1)
                    }
                    @ev.flash [temB] .rgbv(31, 31, 31, 31) .time(5)
                }
            }
        }
    }

    @if `temE bl {
        @if `!(underLaneFlag & UNDER_LANE_HITBIT) bl {
            //接触フラグ
            bitOn(underLaneFlag, UNDER_LANE_HITBIT)
            //スロットが起動していない状態で全て揃った場合、スロットを起動する
            // bit 1111
            @if `slotState != GIM_ST_ACTIVATED && (underLaneFlag & UNDER_LANE_BITMASK) == UNDER_LANE_BITMASK bl {
                slotState = GIM_ST_ACTIVATED
                pbDisplay(DI_ST_NORMAL, "\c[2]スロットチャンス！")
                @se.play "fc_get1" .opt(80, 100, 50)
            } .else bl {
                @se.play "fc_coin1" .opt(80, 100, 50)
            }
        }
    } .else bl {
        bitOff(underLaneFlag, UNDER_LANE_HITBIT)
    }
}

//--------------------------------
//看板
//向きに応じたレーンを通ると追加でボーナスが入る
//上:ランプ 下:下レーン 右:右レーン 左:左レーン
mev[MEV_BOARD] .pos(11, 16) .name("看板")
mep[1] .body(CHARSET_SLOT, 1) .dir.up .anim.fixDir.step .priority.middle .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_MIDDLE bl {
        @ev.abort
    }

    //判定
    pbBallToArea(temA, unusedV,
    GIM_LAYER_MID, self.id, SHARP_RECT, 0, 0, -10, -8, 10, 8)
    @if temA < 0 bl {
        @ev.abort
    }
    //スコア
    pbAddScore(NUM_TYPE_BONUS, BONUS_BOARD, 0)
    //向きを変える
    @se.play "Wind4" .opt(80, 100, 50)
    @ev.flash .self .rgbv(31, 31, 31, 31) .time(2)
    @ev.setAction  .self .freq(7) .skippable .act {
        .turnRight
    }
    //向き
    boardDir = (boardDir + 1) % 4
    //少し待つ
    @wait(5)
}


//--------------------------------
//リール
//正面で揃えるとセンターポストが起動、あるいは延長する
def {
    UNDER_REEL_NUM = 2
}
mev[MEV_UNDER_REEL_LEFT] .pos(7, 22) .name("左リール")
mep[1] .body(CHARSET_SLOT, 4) .dir.up .anim.fix .priority.low bl {}
mev[MEV_UNDER_REEL_RIGHT] .pos(11, 22) .name("右リール")
mep[1] .body(CHARSET_SLOT, 6) .dir.up .anim.fix .priority.low .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_LOW bl {
        underReelFlag = 0//接触フラグを初期化する
        @ev.abort
    }
    //左右両方の判定をイベント一つで行う
    @loop UNDER_REEL_NUM .dst(idxA) bl {
        //a:idx b:event id c:bit d:hit id
        temB = MEV_UNDER_REEL_LEFT + idxA
        temC = 1 << idxA
        //衝突判定
        pbBallToArea(temD, unusedV,
        GIM_LAYER_MID, temB, SHARP_RECT, 0, 0, -12,-24,12,12)
        @if temD >= 0 bl {
            @if `!(underReelFlag & temC) bl {
                //フラグ
                bitOn(underReelFlag, temC)

                //重なると回転する
                //キャラセット番号
                temD = idxA * 2 + 4
                @ev.setAction[temB] .freq(8) .skippable .act {}
                @ev.addAction .setBody(CHARSET_SLOT, temD)
                @ev.addAction .turnRight
                @ev.flash[temB] .rgbv(31, 31, 31, 31) .time(5)
                @se.play "Cursor1" .opt(80, 100, 50)

                //動作が終わるまで一瞬待つ
                @wait(0)
                //向きが同じだとボーナスが得られる
                @if `ev[MEV_UNDER_REEL_LEFT].dir == ev[MEV_UNDER_REEL_RIGHT].dir bl {
                    @wait(2)
                    //下で揃うとセンターポストを起動する
                    @if .ev[MEV_UNDER_REEL_LEFT] .facingDown() bl {
                        //スコア
                        pbAddScore(NUM_TYPE_BONUS, BONUS_UNDER_REEL_DOWN, 0)

                        //ファルコン
                        temA = FALCON_AREA_UNDER_REEL
                        cm_falconMission()
                        
                        //センターポストを起動するか、延長する
                        _activateCenterPost(CETNER_POST_ADD_SECOND)
                        pbDisplay(DI_ST_NORMAL, __str("\c[2]センターポスト +",  CETNER_POST_ADD_SECOND, "s"))

                        @se.play "Flash2" .opt(100, 100, 50)

                    } .else bl {
                        //スコア
                        pbAddScore(NUM_TYPE_BONUS, BONUS_UNDER_REEL_MATCH, 0)

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

                    //かっこいいポーズ
                    @ev.flash [MEV_UNDER_REEL_LEFT] .rgbv(31, 31, 31, 31) .time(5)
                    @ev.setAction [MEV_UNDER_REEL_LEFT] .freq(8) .skippable .act {
                        .setBody(CHARSET_SLOT, 5)
                    }
                    @ev.flash [MEV_UNDER_REEL_RIGHT] .rgbv(31, 31, 31, 31) .time(5)
                    @ev.setAction [MEV_UNDER_REEL_RIGHT] .freq(8) .skippable .act {
                        .setBody(CHARSET_SLOT, 7)
                    }
                    @wait(2)

                }
            }
        } .else bl {
            //玉が離れると解除される
            @if `underReelFlag & temC bl {
                bitOff(underReelFlag, temC)
            }
        }
    }
}

//--------------------------------
//スロット
def {
    SLOT_CELL_X = 0
    SLOT_CELL_Y = 17
    SLOT_RAD = 8
    SLOT_CELL_NUM = 3
    SLOT_CELL_WIDTH = 32
    SLOT_CELL_PIC_NUM = 6
    SLOT_PATTERN = 4
    SLOT_SPEED = 3
    SLOT_CHANCE = 3
    SLOT_CELL_LENGTH = SLOT_CELL_WIDTH * SLOT_PATTERN

    //状態
    SL_ST_INPUT = 0
    SL_ST_SLIP
    SL_ST_WAIT
    SL_ST_END

    //属性
    SL_TYPE_FIRE = 0
    SL_TYPE_ICE
    SL_TYPE_STONE
    SL_TYPE_THUNDER

    //アニメ
    SL_ANIM_FIRE = 2
    SL_ANIM_ICE
    SL_ANIM_STONE
    SL_ANIM_THUNDER
}
mev[MEV_SLOT] .pos(9, 22) .name("スロット")
mep[1] .body(CHARSET_SLOT, 0) .dir.up .anim.fixDir.step .trans .priority.low bl {}
mep[2] .body(CHARSET_SLOT, 0) .dir.right .anim.fixDir.step .priority.low .cond(v[__id(slotState)] == GIM_ST_ACTIVATED) .parallel bl {
    //簡易判定
    @if `!ROUGHLY_CHECK_BALL_LOW bl {
        @ev.abort
    }
    
    //衝突判定
    pbBallToArea(temA, unusedV,
    GIM_LAYER_MID, self.id, SHARP_CIRCLE, 0, SLOT_RAD, 0, 0, 0, 0)
    @if temA < 0 bl {
        @ev.abort
    }

    //固定した玉ID
    slotCatchId = temA

    //玉をロックする
    pbBallFunction(BA_FUNC_SET_POS, slotCatchId, self.id, GIM_LAYER_MID, 18, -4)
    pbBallFunction(BA_FUNC_LOCK,    slotCatchId, 0, 0, 0, 0)
    @wait(0)
    startEventMode()

    //詠唱準備
    @ev.setAction .self .freq(8) .skippable .act {
        .faceLeft
    }
    @se.play "Blow1" .opt(100, 120, 50)

    //下にスクロール
    //ボールロックとの間にウェイトを設ける
    //1Fに複数回のスクロールが重なるとピクチャがずれるようだ
    @wait(0)
    setScroll(0, 16*16, 10)

    @wait(4)

    //二人をどかす
    @ev.setAction [MEV_UNDER_REEL_LEFT] .freq(8) .skippable .act {
        .beginThrough
        .beginJump
        .moveUp
        .endJump
    }
    @ev.setAction [MEV_UNDER_REEL_RIGHT] .freq(8) .skippable .act {
        .beginThrough
        .beginJump
        .moveUp
        .endJump
    }

    //背景を用意する
    V2_set(temD,
        ev[MEV_SLOT].scrx + SLOT_CELL_X,
        ev[MEV_SLOT].scry + SLOT_CELL_Y
    )
    @pic.show[PIC_SLOT_BASE] .pos(temD, temE) .center .trans(100) slotBasePicCmd
    @pic.move[PIC_SLOT_BASE] .relative .pos(0, 0) .scale(0) .trans(-100) .time(1)
    @wait(1)

    //リールの位置をランダムにする
    @loop SLOT_CELL_NUM .dst(idxA) bl {
        temA = __id(slotPlayLeft) + idxA
        v[temA] = rnd(0 ,SLOT_CELL_LENGTH)
    }

    @loop SLOT_CHANCE bl {
        @ev.flash .self .rgbv(31, 31, 31, 31) .time(5)
        @ev.setAction .self .freq(8) .skippable .act {
            .faceDown
        }
        @se.play "Magic2" .opt(100, 100, 50)

        //入力初期化
        slotPlayState  = SL_ST_INPUT
        slotPlayStep   = 0
        //スロット開始
        @loop bl {
            @wait(0)
            //回転
            @loop SLOT_CELL_NUM .dst(idxA) bl {
                //a:v id b:p id c:cell
                temA = __id(slotPlayLeft) + idxA
                @if slotPlayStep <= idxA bl {
                    v[temA] = (v[temA] + SLOT_SPEED) % SLOT_CELL_LENGTH
                }
                @loop 2 .dst(idxB) {
                    temB = PIC_SLOT_CELL + idxB + idxA * 2
                    temC = 1 + idxA * SLOT_PATTERN + (v[temA] / SLOT_CELL_WIDTH + idxB + SLOT_PATTERN) % SLOT_PATTERN
                    V2_set(temD,
                        ev[MEV_SLOT].scrx + SLOT_CELL_X + (idxA - 1) * SLOT_CELL_WIDTH,
                        ev[MEV_SLOT].scry + SLOT_CELL_Y + v[temA] % SLOT_CELL_WIDTH - idxB * SLOT_CELL_WIDTH
                    )
                    @pic.show[temB] .pos(temD, temE) .center .cell(temC) slotCellPicCmd
                }
            }

            pseudoSwitchState(slotPlayState,
            [   SL_ST_INPUT, bl {
                    @if `leftFlipperInput == 1 || rightFlipperInput == 1 bl {
                        slotPlayState = SL_ST_SLIP
                    }
                },
                SL_ST_SLIP, bl {
                    temA = __id(slotPlayLeft) + slotPlayStep
                    @if `v[temA] / SLOT_CELL_WIDTH != (v[temA] + SLOT_SPEED) / SLOT_CELL_WIDTH bl {
                        v[temA] = ((v[temA] + SLOT_SPEED) % SLOT_CELL_LENGTH) / SLOT_CELL_WIDTH * SLOT_CELL_WIDTH

                        @se.play "Open2" .opt(100, 150, 50)
                        
                        slotPlayStep += 1
                        @if slotPlayStep >= SLOT_CELL_NUM bl {
                            slotPlayState = SL_ST_END
                        } .else bl {
                            slotPlayState = SL_ST_WAIT
                        }
                    }
                },
                SL_ST_WAIT, bl {
                    @if `leftFlipperInput <= 0 && rightFlipperInput <= 0 bl {
                        slotPlayState = SL_ST_INPUT
                    }
                },
                SL_ST_END, bl {
                    @wait(2)

                    //揃った
                    @if `slotPlayLeft == slotPlayCenter && slotPlayLeft == slotPlayRight bl {
                        temC = slotPlayLeft / SLOT_CELL_WIDTH
                        pseudoSwitchState(temC,
                        [   SL_TYPE_FIRE, bl {
                                pbDisplay(DI_ST_ZOOM, __str("\c[2]Ⅲファイア : +", BONUS_SLOT_FIRE))
                                pbAddScore(NUM_TYPE_BONUS, BONUS_SLOT_FIRE, 0)
                            },
                            SL_TYPE_ICE, bl {
                                pbDisplay(DI_ST_ZOOM, __str("\c[2]Ⅲアイス : セーバー +", BONUS_SLOT_ICE))
                                pbAddScore(NUM_TYPE_BONUS, BONUS_SLOT_ICE, 0)

                                //センターポスト60s + キッカー起動
                                _activateCenterPost(60)
                                _activateLeftKickBack()
                                _activateRightKickBack()
                            },
                            SL_TYPE_STONE, bl {
                                cm_extendChance()
                                pbDisplay(DI_ST_ZOOM, __str("\c[2]Ⅲストーン : エクストラホール +", BONUS_SLOT_STONE))
                                pbAddScore(NUM_TYPE_BONUS, BONUS_SLOT_STONE, 0)
                                cm_updateCenterHole()
                            },
                            SL_TYPE_THUNDER, bl {
                                pbDisplay(DI_ST_ZOOM, __str("\c[2]Ⅲサンダー : マルチプライヤー +", MULTI_SLOT_THUNDER))
                                pbAddScore(NUM_TYPE_MULTI, MULTI_SLOT_THUNDER, 0)
                            }
                        ] )

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

                        @wait(4)

                        //アニメーション
                        V2_set(temA,
                            ev[MEV_SLOT].scrx + SLOT_CELL_X,
                            ev[MEV_SLOT].scry + SLOT_CELL_Y
                        )
                        temC = slotPlayLeft / SLOT_CELL_WIDTH
                        temC = [SL_ANIM_FIRE, SL_ANIM_ICE, SL_ANIM_STONE, SL_ANIM_THUNDER][temC]
                        @anim.show [temC] {
                            .pos(temA, temB)
                            .buffer(ANIM_BUFFER_EVENT)
                            .reverse(0)
                        }

                        //回数が残っていても離脱する
                        @wait(8)
                        @break(3)//疑似switch文もloopを使っている

                    //外れ
                    } .else bl {
                        @se.play "Cancel2" .opt(100, 100, 50)
                        @ev.setAction .self .freq(8) .skippable .act {
                            .faceLeft
                        }
                        @wait(5)
                        @break(2)
                    }
                }
            ] )
        }
    }

    //終了
    //ピクチャを消す
    @loop SLOT_CELL_PIC_NUM .dst(idxA) bl {
        temA = PIC_SLOT_CELL + idxA
        @pic.move[temA] .relative .pos(0, 0) .trans(100) .scale(0) .time(1)
    }
    @wait(1)
    @pic.move[PIC_SLOT_BASE] .relative .pos(0, 0) .trans(100) .scale(0) .time(1)
    @wait(1)

    //向きを戻す
    @ev.setAction .self .freq(8) .skippable .act {
        .faceRight
    }

    //二人を元の位置に
    @ev.setAction [MEV_UNDER_REEL_LEFT] .freq(8) .skippable .act {
        .beginThrough
        .beginJump
        .moveDown
        .endJump
    }
    @ev.setAction [MEV_UNDER_REEL_RIGHT] .freq(8) .skippable .act {
        .beginThrough
        .beginJump
        .moveDown
        .endJump
    }
    @wait(10)

    //玉を打ち出す
    pbBallFunction(BA_FUNC_UNLOCK,  slotCatchId, 0, 0, 0, 0)
    pbBallFunction(BA_FUNC_SET_VEL, slotCatchId, 3 * UNIT_POS, 80 * UNIT_ANGLE, 0, 0)
    endEventMode()
    slotCatchId = -1
    @se.play "energy1" .opt(90, 120, 50)
    @wait(5)

    //下レーンを初期化する
    cm_initUnderLane()
    //終了
    @ev.flash .self .rgbv(0, 0, 0, 31) .time(5)
    slotState = GIM_ST_HIDE
}

//--------------------------------
//シェイド2
//下に落ちた玉をプランジャーレーンに戻す
def {
    COFFIN_SX = 7
    COFFIN_SY = 10
    COFFIN_EX = 17
    COFFIN_EY = 22
    COFFIN_X = 16
    COFFIN_Y = 21

    COFFIN_COUNT = 6
    COFFIN_RAD = 12
    COFFIN_ANIM = 11
}

mev[MEV_COFFIN] .pos(COFFIN_X, COFFIN_Y) .name("早すぎる埋葬")
mep[1] bl {}
mep[2] .body(CHARSET_TARGET_1, 1) .dir.left .anim.fixDir.step .priority.high .cond(v[__id(exitGateState)] == GIM_ST_ACTIVATED) .parallel bl {
    //出現
    @ev.setPos .self .pos(COFFIN_SX, COFFIN_SY)
    @ev.setAction .self .freq(8) .skippable {
        .setBody(CHARSET_TARGET_1, 2)
        .beginThrough
        .faceDown
    }

    @se.play "Darkness1" .opt(80, 100, 50)
    @ev.flash .self .rgbv(0, 0, 0, 31) .time(5)
    @wait(8)
    @ev.setPos .self .pos(COFFIN_X, COFFIN_Y)
    @se.play "Attack2" .opt (100, 120, 50)
    @ev.flash .self .rgbv(0, 0, 0, 31) .time(2)
    @wait(2)
    
    @loop bl {
        @wait(0)
        //簡易判定
        @if `!ROUGHLY_CHECK_BALL_LOW bl {
            @continue
        }
        //衝突判定
        pbBallToArea(temA, unusedV,
        GIM_LAYER_MID, self.id, SHARP_CIRCLE, 0, COFFIN_RAD, 0, 4, 0, 0)
        @if temA < 0 bl {
            @continue
        }

        //ボーナス
        // pbAddScore(NUM_TYPE_BONUS, BONUS_COFFIN, 0)

        //固定した玉ID
        exitGateCatchId = temA
        //玉をロックする
        pbBallFunction(BA_FUNC_HIDE, exitGateCatchId, 0, 0, 0, 0)
        startEventMode()
        //スキルショットイベントを初期化
        _initSkillShot()

        @se.play "Earth2" .opt(90, 80, 50)
        @scr.flash .once(4) .rgbv(0, 0, 0, 16)
        @wait(5)
        @se.play "voice_dehanai" .opt(90, 100, 50)

        //相対位置
        V2_set(temB,
            COFFIN_EX - COFFIN_X,
            COFFIN_EY - COFFIN_Y
        )
        //跳ねる
        @ev.setAction .self .freq(8) .skippable {
            .faceRight
        }
        @ev.addAction .jump(temB, temC)
        @wait(16)

        //玉を解放する
        endEventMode()
        pbBallFunction(BA_FUNC_SET_POS, exitGateCatchId, self.id, GIM_LAYER_MID, 16, 0)
        pbBallFunction(BA_FUNC_UNLOCK,  exitGateCatchId, 0, 0, 0, 0)
        exitGateCatchId = -1
        @se.play "flipper2" .opt(100, 140, 50)
        @wait(5)

        //戦闘アニメが終わった後、透明になって初期位置に戻る
        @anim.show [COFFIN_ANIM] {
            .self
            .buffer(ANIM_BUFFER_EFFECT)
            .reverse(0)
        }
        @ev.setAction .self .freq(8) .skippable {
            .setBody(CHARSET_TARGET_1, 1)
            .faceLeft
        }
        @wait(10)
        @ev.setPos .self .pos(COFFIN_SX, COFFIN_SY)
        //状態を戻す
        exitGateState = GIM_ST_HIDE
        @ev.abort
    }
}