m_bgm OK (#222)

* m_demo OK

* camera fix

* m_bgm OK

4 files changed, 2080 insertions, 5 deletions

diff --git a/src/code/game.c b/src/code/game.c
index 4edc1fb..f92edd6 100644
--- a/src/code/game.c
+++ b/src/code/game.c
@@ -2,7 +2,7 @@
 #include "gfx.h"
 #include "m_controller.h"
 #include "m_debug.h"
-#include "67E840.h"
+#include "m_bgm.h"
 #include "speed_meter.h"
 #include "graph.h"
 #include "libu64/debug.h"
@@ -284,7 +284,7 @@ void game_ct(Game* game, GameStateFunc init, GraphicsContext* gfxCtx) {
 
     init(game);
 
-    func_8005F020_jp();
+    mBGM_init();
     func_800D88B0_jp(&B_80145020_jp);
     func_800D3E14_jp(game->gfxCtx);
 }
diff --git a/src/code/m_bgm.c b/src/code/m_bgm.c
new file mode 100644
index 0000000..f9389d4
--- /dev/null
+++ b/src/code/m_bgm.c
@@ -0,0 +1,2075 @@
+#include "m_bgm.h"
+#include "6E3240.h"
+#include "audio.h"
+#include "m_common_data.h"
+#include "m_field_info.h"
+#include "m_melody.h"
+#include "m_player_lib.h"
+#include "m_scene_table.h"
+#include "macros.h"
+#include "overlays/actors/player_actor/m_player.h"
+#include "prevent_bss_reordering.h"
+
+// TODO : revisit for iQue, has some nonmatchings
+
+Bgm M_bgm;
+
+int mBGM_check_MD(u8 num) {
+    return ((num >= 0x80 && num <= 0xB3) || (num >= 0xB4 && num <= 0xB6));
+}
+
+int mBGM_check_ignore_talk_volume(u8 num) {
+    return BGM_CHECK_BGM_DATA(num);
+}
+
+int func_8005ACA8_jp(u8 num) {
+    return num == 40;
+}
+
+void mBGMElem_default_set(BgmElement* element) {
+    static BgmElement default_data = { 255, 0, 0, 0x168, 0x168 };
+    bcopy(&default_data, element, sizeof(BgmElement));
+}
+
+int mBGMClock_after_time_check(BgmClock* clock, u32 checktTime, u32 checkMask) {
+    u32 timeNow = clock->now & checkMask;
+    u32 timeCheck = checktTime & checkMask;
+
+    return timeNow >= timeCheck;
+}
+
+int mBGMClock_over_time_check(BgmClock* clock, u32 checktTime, u32 checkMask) {
+    u32 timeNow = clock->now & checkMask;
+    u32 timePrior = clock->prior & checkMask;
+    u32 timeCheck = checktTime & checkMask;
+
+    if (timeNow >= timePrior) {
+        return (timeCheck > timePrior && timeCheck <= timeNow);
+
+    } else {
+        return (timeCheck > timePrior || timeCheck <= timeNow);
+    }
+}
+
+int mBGMClock_range_time_check(BgmClock* clock, u32 checktTime0, u32 checktTime1, u32 checkMask) {
+    u32 timeNow = clock->now & checkMask;
+    u32 timeCheck0 = checktTime0 & checkMask;
+    u32 timeCheck1 = checktTime1 & checkMask;
+
+    if (timeCheck1 >= timeCheck0) {
+        return (timeNow >= timeCheck0 && timeNow < timeCheck1);
+
+    } else {
+        return (timeNow >= timeCheck0 || timeNow < timeCheck1);
+    }
+}
+
+void mBGMClock_now_set(BgmClock* clock) {
+    lbRTC_time_c* time = &common_data.time.rtcTime;
+
+    clock->prior = clock->now;
+    clock->now = BGM_RTC_TIME_TO_BGM_TIME(time->month, time->day, time->hour, time->min, time->sec);
+}
+
+void mBGMClock_move(BgmClock* clock, UNUSED Game_Play* play) {
+    mBGMClock_now_set(clock);
+}
+
+void mBGMClock_ct(BgmClock* clock) {
+    bzero(clock, sizeof(BgmClock));
+    mBGMClock_now_set(clock);
+    clock->prior = clock->now;
+}
+
+void mBGMDemo_make_scene_bgm(BgmDemo* demo) {
+    if (demo->element.num == 255 && mFI_CheckFieldData()) {
+        u16 fieldId = mFI_GetFieldId();
+        u8 num;
+
+        switch (fieldId) {
+            case 0x5000:
+            case 0x5001:
+                num = 42;
+                break;
+
+            case 0x5002:
+                if (common_data.save.sceneNo == SCENE_PLAYERSELECT_SAVE) {
+                    num = 46;
+                } else {
+                    num = 43;
+                }
+                break;
+
+            default:
+                num = 255;
+                break;
+        }
+
+        if (num != 255) {
+            mBGMElem_default_set(&demo->element);
+            demo->element.num = num;
+            mBGMPsComp_make_ps_demo(num, 0x168);
+        }
+    }
+}
+
+void mBGMDemo_delete_scene_bgm(BgmDemo* demo) {
+    if (demo->element.num != 255) {
+        mBGMPsComp_delete_ps_demo(demo->element.num, 0x168);
+        demo->element.num = 255;
+    }
+}
+
+void mBGMDemo_move(BgmDemo* demo, UNUSED Game_Play* play) {
+    if (demo->deleteFlag) {
+        mBGMDemo_delete_scene_bgm(demo);
+    }
+
+    if (demo->makeFlag) {
+        mBGMDemo_make_scene_bgm(demo);
+    }
+
+    demo->makeFlag = FALSE;
+    demo->deleteFlag = FALSE;
+}
+
+void mBGMDemo_scene_bgm_make_req() {
+    M_bgm.demo.makeFlag = TRUE;
+}
+
+void mBGMDemo_scene_bgm_delete_req() {
+    M_bgm.demo.deleteFlag = TRUE;
+}
+
+void mBGMDemo_ct(BgmDemo* demo) {
+    bzero(demo, sizeof(BgmDemo));
+    mBGMElem_default_set(&demo->element);
+}
+
+void mBGMRoom_shop_close_time_set(BgmRoom* room) {
+    if (mFI_CheckFieldData()) {
+        u16 fieldId = mFI_GetFieldId();
+
+        if (fieldId == 0x3001 || fieldId == 0x3006 || fieldId == 0x3007 || fieldId == 0x3008 || fieldId == 0x3009) {
+            lbRTC_time_c time;
+
+            bzero(&time, sizeof(lbRTC_time_c));
+            time.hour = mSP_GetShopCloseTime_Bgm();
+
+            lbRTC_Sub_mm(&time, 5);
+            room->shopCloseTime1 = BGM_TIME_TO_SHOP_CLOSE_TIME(time.hour, time.min, time.sec);
+
+            lbRTC_Sub_ss(&time, 5);
+            room->shopCloseTime0 = BGM_TIME_TO_SHOP_CLOSE_TIME(time.hour, time.min, time.sec);
+        }
+    }
+}
+
+u8 mBGMRoom_make_scene_bgm_shop_get(BgmRoom* room, u16 fieldId) {
+    u8 num;
+
+    if (mEv_CheckRealArbeit() == FALSE &&
+        mBGMClock_after_time_check(&M_bgm.clock, room->shopCloseTime1,
+                                   BGM_CLOCK_CHECK_HOUR | BGM_CLOCK_CHECK_MIN | BGM_CLOCK_CHECK_SEC)) {
+        if (fieldId == 0x3001) {
+            num = 79;
+        } else if (fieldId == 0x3006) {
+            num = 80;
+        } else if (fieldId == 0x3007) {
+            num = 81;
+        } else {
+            num = 82;
+        }
+    } else {
+        if (fieldId == 0x3001) {
+            num = 44;
+        } else if (fieldId == 0x3006) {
+            num = 37;
+        } else if (fieldId == 0x3007) {
+            num = 38;
+        } else {
+            num = 39;
+        }
+    }
+
+    return num;
+}
+
+void mBGMRoom_make_scene_bgm(BgmRoom* room) {
+    if (room->element.num == 255 && mFI_CheckFieldData()) {
+        u16 fieldId = mFI_GetFieldId();
+        u8 num;
+
+        switch (fieldId) {
+            case 0x3001:
+            case 0x3006:
+            case 0x3007:
+            case 0x3008:
+            case 0x3009:
+                num = mBGMRoom_make_scene_bgm_shop_get(room, fieldId);
+                break;
+
+            case 0x3002:
+                num = 25;
+                break;
+
+            case 0x3003:
+                if (common_data.unk10A6B != 0) {
+                    num = 62;
+                } else {
+                    num = 41;
+                }
+                break;
+
+            case 0x3004:
+                num = 45;
+                break;
+
+            case 0x3005:
+                num = 26;
+                break;
+
+            case 0x300A:
+                num = 77;
+                break;
+
+            default:
+                num = 255;
+                break;
+        }
+
+        if (num != 255) {
+            mBGMElem_default_set(&room->element);
+            room->element.num = num;
+            mBGMPsComp_make_ps_room(num, 0x168);
+        }
+    }
+}
+
+void mBGMRoom_delete_scene_bgm(BgmRoom* room) {
+    if (room->element.num != 255) {
+        mBGMPsComp_delete_ps_room(room->element.num, 0x168);
+        room->element.num = 255;
+    }
+}
+
+s32 mBGMRoom_shop_close_check(BgmRoom* room) {
+    s32 res = FALSE;
+    s32 fadeoutFlag = FALSE;
+
+    if (mFI_CheckFieldData()) {
+        u16 fieldId = mFI_GetFieldId();
+
+        if (fieldId == 0x3001 || fieldId == 0x3006 || fieldId == 0x3007 || fieldId == 0x3008 || fieldId == 0x3009) {
+            s32 realArbeit = mEv_CheckRealArbeit();
+
+            fadeoutFlag =
+                realArbeit == FALSE &&
+                mBGMClock_range_time_check(&M_bgm.clock, room->shopCloseTime0, room->shopCloseTime1,
+                                           BGM_CLOCK_CHECK_HOUR | BGM_CLOCK_CHECK_MIN | BGM_CLOCK_CHECK_SEC) != FALSE;
+
+            res = realArbeit == FALSE &&
+                  mBGMClock_over_time_check(&M_bgm.clock, room->shopCloseTime1,
+                                            BGM_CLOCK_CHECK_HOUR | BGM_CLOCK_CHECK_MIN | BGM_CLOCK_CHECK_SEC) != FALSE;
+        }
+    }
+
+    if (fadeoutFlag && room->shopFadeoutFlag == FALSE) {
+        mBGMPsComp_make_ps_quietRoom(0x13DE);
+        room->shopFadeoutFlag = TRUE;
+    } else if (!fadeoutFlag && room->shopFadeoutFlag) {
+        mBGMPsComp_delete_ps_quietRoom();
+        room->shopFadeoutFlag = FALSE;
+    }
+
+    return res;
+}
+
+void mBGMRoom_move(BgmRoom* room, UNUSED Game_Play* play) {
+    if (mBGMRoom_shop_close_check(room)) {
+        room->deleteFlag = TRUE;
+        room->makeFlag = TRUE;
+    }
+
+    if (room->deleteFlag) {
+        mBGMRoom_delete_scene_bgm(room);
+    }
+
+    if (room->makeFlag) {
+        mBGMRoom_make_scene_bgm(room);
+    }
+
+    room->makeFlag = FALSE;
+    room->deleteFlag = FALSE;
+}
+
+void mBGMRoom_scene_bgm_make_req() {
+    M_bgm.room.makeFlag = TRUE;
+}
+
+void mBGMRoom_scene_bgm_delete_req() {
+    M_bgm.room.deleteFlag = TRUE;
+}
+
+void mBGMRoom_ct(BgmRoom* room) {
+    bzero(room, sizeof(BgmRoom));
+    mBGMElem_default_set(&room->element);
+}
+
+void mBGMTime_signal_melody(BgmTime* time) {
+    static u8 signal_melody_buf[8];
+
+    if (mEv_CheckFirstIntro() == FALSE && mEv_CheckTitleDemo() != -9 && mFI_CheckFieldData() &&
+        FI_GET_TYPE(mFI_GetFieldId()) != 0x5000 && time->newYearEventFlag == FALSE) {
+        mMld_GetMelody(signal_melody_buf);
+        sAdo_Inst(0xFF, signal_melody_buf);
+    }
+}
+
+int mBGMTime_silent_check(BgmTime* time) {
+    if (time->newYearEventFlag) {
+        return FALSE;
+    }
+
+    return mBGMClock_range_time_check(&M_bgm.clock, BGM_MIN_TIME_TO_BGM_MIN_TIME(59) | BGM_SEC_TIME_TO_BGM_SEC_TIME(52),
+                                      BGM_MIN_TIME_TO_BGM_MIN_TIME(0) | BGM_SEC_TIME_TO_BGM_SEC_TIME(16),
+                                      BGM_CLOCK_CHECK_MIN | BGM_CLOCK_CHECK_SEC);
+}
+
+void mBGMTime_new_year_ev_flag_set() {
+    M_bgm.time.newYearEventFlag = TRUE;
+}
+
+void mBGMTime_new_year_ev_flag_clr() {
+    M_bgm.time.newYearEventFlag = FALSE;
+}
+
+void mBGMTime_move_wait(BgmTime* time, UNUSED Game_Play* play) {
+    if (mBGMTime_silent_check(time)) {
+        mBGMPsComp_make_ps_time();
+        time->moveFunc = &mBGMTime_move_change;
+    }
+}
+
+void mBGMTime_move_change(BgmTime* time, UNUSED Game_Play* play) {
+    if (mBGMClock_over_time_check(&M_bgm.clock, 0, BGM_CLOCK_CHECK_MIN | BGM_CLOCK_CHECK_SEC)) {
+        mBGMTime_signal_melody(time);
+    }
+
+    if (mBGMTime_silent_check(time) == FALSE) {
+        mBGMPsComp_delete_ps_time();
+        time->moveFunc = &mBGMTime_move_wait;
+    }
+}
+
+void mBGMTime_move(BgmTime* time, Game_Play* play) {
+    time->moveFunc(time, play);
+}
+
+void mBGMTime_ct(BgmTime* time) {
+    bzero(time, sizeof(BgmTime));
+    time->moveFunc = &mBGMTime_move_wait;
+}
+
+s32 mBGMFieldSuddenEv_flag_check_arbeit(UNUSED BgmFieldSuddenEvent* fieldSuddenEvent, UNUSED Game_Play* play) {
+    return mEv_CheckFirstJob();
+}
+
+typedef s32 (*BgmFieldSuddenEventFunc)(BgmFieldSuddenEvent*, Game_Play*);
+
+void mBGMFieldSuddenEv_flag_set(BgmFieldSuddenEvent* fieldSudden, Game_Play* play) {
+    static BgmFieldSuddenEventFunc ev_chk[] = { NULL, &mBGMFieldSuddenEv_flag_check_arbeit };
+
+    fieldSudden->priorFlag = fieldSudden->flag;
+    fieldSudden->flag = 0;
+
+    if (mFI_CheckFieldData() && FI_GET_TYPE(mFI_GetFieldId()) == 0) {
+        s32 i = 0;
+        u32 mask = 1;
+
+        for (; i < ARRAY_COUNT(ev_chk); i++) {
+            if (ev_chk[i] != NULL && ev_chk[i](fieldSudden, play) != FALSE) {
+                fieldSudden->flag |= mask;
+            }
+
+            mask <<= 1;
+        }
+    }
+}
+
+void mBGMFieldSuddenEv_ps_compose(BgmFieldSuddenEvent* fieldSudden, UNUSED Game_Play* play) {
+    static u8 bgm_num_data[] = { 255, 52 };
+    s32 now;
+    s32 prior;
+    s32 i;
+    s32 mask;
+
+    for (i = 0, mask = 1; i < ARRAY_COUNT(bgm_num_data); i++) {
+        now = (fieldSudden->flag & mask) != 0;
+        prior = (fieldSudden->priorFlag & mask) != 0;
+
+        if (!now && prior) {
+            mBGMPsComp_delete_ps_fieldSuddenEv(bgm_num_data[i], 0x168);
+        }
+
+        if (now && !prior) {
+            mBGMPsComp_make_ps_fieldSuddenEv(bgm_num_data[i], 0x168, i);
+        }
+
+        mask <<= 1;
+    }
+}
+
+void mBGMFieldSuddenEv_move(BgmFieldSuddenEvent* fieldSudden, Game_Play* play) {
+    mBGMFieldSuddenEv_flag_set(fieldSudden, play);
+    mBGMFieldSuddenEv_ps_compose(fieldSudden, play);
+}
+
+void mBGMFieldSuddenEv_ct(BgmFieldSuddenEvent* fieldSudden) {
+    bzero(fieldSudden, sizeof(BgmFieldSuddenEvent));
+}
+
+s32 mbgm_pattern_data[3][3] = { { 2, 2, 2 }, { 0, 1, 2 }, { 0, 0, 2 } };
+
+BgmEventData mbgm_event_data[] = {
+    { -1, 255, BGM_EVENT_AREA_BLOCK, 0x8000 }, { 11, 55, BGM_EVENT_AREA_BLOCK, 0x8000 },
+    { 13, 53, BGM_EVENT_AREA_EVERYWHERE, 0 },  { 26, 54, BGM_EVENT_AREA_EVERYWHERE, 0 },
+    { 12, 56, BGM_EVENT_AREA_BLOCK, 4 },       { 16, 27, BGM_EVENT_AREA_BLOCK, 4 },
+    { 21, 30, BGM_EVENT_AREA_BLOCK, 0x8000 },  { 22, 30, BGM_EVENT_AREA_BLOCK, 0x8000 },
+    { 8, 27, BGM_EVENT_AREA_BLOCK, 4 },        { 10, 28, BGM_EVENT_AREA_BLOCK, 4 },
+    { 7, 29, BGM_EVENT_AREA_BLOCK, 4 },        { 9, 60, BGM_EVENT_AREA_BLOCK, 4 },
+    { 6, 31, BGM_EVENT_AREA_BLOCK, 0x8000 },   { -1, 32, BGM_EVENT_AREA_BLOCK, 0x8000 },
+    { -1, 33, BGM_EVENT_AREA_BLOCK, 0x8000 },  { -1, 34, BGM_EVENT_AREA_BLOCK, 0x8000 },
+    { -1, 35, BGM_EVENT_AREA_BLOCK, 0x8000 },  { -1, 57, BGM_EVENT_AREA_BLOCK, 0x8000 },
+    { 3, 59, BGM_EVENT_AREA_BLOCK, 4 },        { -1, 36, BGM_EVENT_AREA_EVERYWHERE, 0 },
+    { -1, 61, BGM_EVENT_AREA_EVERYWHERE, 0 },
+};
+
+s32 mBGMFieldSchedEv_bl_attr_get(s32 blockX, s32 blockZ, s32 eventArea, u32 blockType) {
+    s32 attr = BGM_BL_ATTRIBUTE_INACTIVE;
+
+    if (eventArea == BGM_EVENT_AREA_EVERYWHERE) {
+        attr = BGM_BL_ATTRIBUTE_ACTIVE;
+    } else if (blockType != 0) {
+        s32 eventBlockX;
+        s32 eventBlockZ;
+
+        if (mFI_BlockKind2BkNum(&eventBlockX, &eventBlockZ, blockType)) {
+            s32 diffBlockX = eventBlockX - blockX;
+            s32 diffBlockZ = eventBlockZ - blockZ;
+
+            if (diffBlockX == 0 && diffBlockZ == 0) {
+                attr = BGM_BL_ATTRIBUTE_ACTIVE;
+            } else if (eventArea == BGM_EVENT_AREA_BLOCK) {
+                diffBlockX = ABS(diffBlockX);
+                diffBlockZ = ABS(diffBlockZ);
+
+                if ((diffBlockX == 0 && diffBlockZ == 1) || (diffBlockX == 1 && diffBlockZ == 0)) {
+                    attr = BGM_BL_ATTRIBUTE_NEARBY;
+                }
+            }
+        }
+    }
+
+    return attr;
+}
+
+s32 mBGMFieldSchedEv_bl_attr_evdata_get(BgmEventData* data, Game_Play* play) {
+    Player* player = get_player_actor_withoutCheck(play);
+    s32 attr = BGM_BL_ATTRIBUTE_MAX;
+
+    if (player != NULL) {
+        s32 wadeCheck = mFI_CheckPlayerWade(0) || mFI_CheckPlayerWade(3);
+        s32 validPos;
+        s32 blockX;
+        s32 blockZ;
+
+        if (wadeCheck) {
+            s32 inform = M_bgm.force.inform;
+
+            if (inform == 3 || inform == 4 || inform == 5 || inform == 6) {
+                xyz_t priorPos;
+
+                xyz_t_move_s_xyz(&priorPos, &common_data.eventDoorData.exitPos);
+                validPos = mFI_Wpos2BlockNum(&blockX, &blockZ, priorPos);
+            } else {
+                validPos = mFI_Wpos2BlockNum(&blockX, &blockZ, player->actor.world.pos);
+            }
+        } else {
+            validPos = mFI_GetNextBlockNum(&blockX, &blockZ);
+        }
+
+        if (validPos) {
+            attr = mBGMFieldSchedEv_bl_attr_get(blockX, blockZ, data->eventArea, data->blockType);
+        }
+    }
+
+    return attr;
+}
+
+void mBGMFieldSchedEv_Info_old_copy(BgmFieldScheduleInfo* info) {
+    if ((info->flag & 1)) {
+        info->flag |= 2;
+    } else {
+        info->flag &= ~2;
+    }
+
+    if ((info->flag & 4)) {
+        info->flag |= 8;
+    } else {
+        info->flag &= ~8;
+    }
+
+    info->priorAttribute = info->attribute;
+}
+
+void mBGMFieldSchedEv_Info_ev_now_set_standard(BgmFieldScheduleInfo* info, BgmEventData* data, UNUSED Game_Play* play,
+                                               s32 eventStartFlag) {
+    if (eventStartFlag || (info->flag & 1)) {
+        if (mEv_check_status(data->eventType, 1)) {
+            info->flag |= 1;
+        } else {
+            info->flag &= ~1;
+        }
+    }
+}
+
+void mBGMFieldSchedEv_Info_ev_now_set_Silence_0(BgmFieldScheduleInfo* info, UNUSED BgmEventData* data,
+                                                UNUSED Game_Play* play, UNUSED s32 eventStartFlag) {
+    s32 eventNow = FALSE;
+
+    if ((info->flag & 4) &&
+        mBGMClock_over_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_DECEMBER, 31, 23, 59, 0),
+                                  BGM_CLOCK_CHECK_ALL) &&
+        mBGMFieldSchedEv_bl_attr_evdata_get(&mbgm_event_data[0], play) == BGM_BL_ATTRIBUTE_ACTIVE) {
+        info->flag |= 0x10;
+    }
+
+    if (mBGMClock_range_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_DECEMBER, 31, 23, 59, 0),
+                                   BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 0, 0, 0), BGM_CLOCK_CHECK_ALL)) {
+        if ((info->flag & 0x10)) {
+            if (mEv_check_status(6, 8)) {
+                eventNow = TRUE;
+            }
+        } else {
+            eventNow = TRUE;
+        }
+    } else {
+        info->flag &= ~0x10;
+    }
+
+    if (eventNow) {
+        info->flag |= 1;
+    } else {
+        info->flag &= ~1;
+    }
+}
+
+void mBGMFieldSchedEv_Info_ev_now_set_CountDown_1(BgmFieldScheduleInfo* info, UNUSED BgmEventData* data,
+                                                  UNUSED Game_Play* play, UNUSED s32 eventStartFlag) {
+    if (mEv_check_status(6, 1) &&
+        mBGMClock_range_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_DECEMBER, 31, 23, 0, 0),
+                                   BGM_RTC_TIME_TO_BGM_TIME(lbRTC_DECEMBER, 31, 23, 30, 0), BGM_CLOCK_CHECK_ALL)) {
+        info->flag |= 1;
+    } else {
+        info->flag &= ~1;
+    }
+}
+
+void mBGMFieldSchedEv_Info_ev_now_set_CountDown_2(BgmFieldScheduleInfo* info, UNUSED BgmEventData* data,
+                                                  UNUSED Game_Play* play, UNUSED s32 eventStartFlag) {
+    if (mEv_check_status(6, 1) &&
+        mBGMClock_range_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_DECEMBER, 31, 23, 30, 0),
+                                   BGM_RTC_TIME_TO_BGM_TIME(lbRTC_DECEMBER, 31, 23, 50, 0), BGM_CLOCK_CHECK_ALL)) {
+        info->flag |= 1;
+    } else {
+        info->flag &= ~1;
+    }
+}
+
+void mBGMFieldSchedEv_Info_ev_now_set_CountDown_3(BgmFieldScheduleInfo* info, UNUSED BgmEventData* data,
+                                                  UNUSED Game_Play* play, UNUSED s32 eventStartFlag) {
+    if (mEv_check_status(6, 1) &&
+        mBGMClock_range_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_DECEMBER, 31, 23, 50, 0),
+                                   BGM_RTC_TIME_TO_BGM_TIME(lbRTC_DECEMBER, 31, 23, 55, 0), BGM_CLOCK_CHECK_ALL)) {
+        info->flag |= 1;
+    } else {
+        info->flag &= ~1;
+    }
+}
+void mBGMFieldSchedEv_Info_ev_now_set_CountDown_4(BgmFieldScheduleInfo* info, UNUSED BgmEventData* data,
+                                                  UNUSED Game_Play* play, UNUSED s32 eventStartFlag) {
+    if (mEv_check_status(6, 1) &&
+        mBGMClock_range_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_DECEMBER, 31, 23, 55, 0),
+                                   BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 0, 0, 0), BGM_CLOCK_CHECK_ALL)) {
+        info->flag |= 1;
+    } else {
+        info->flag &= ~1;
+    }
+}
+
+void mBGMFieldSchedEv_Info_ev_now_set_CountDown_5(BgmFieldScheduleInfo* info, UNUSED BgmEventData* data,
+                                                  Game_Play* play, UNUSED s32 eventStartFlag) {
+    s32 eventNow = FALSE;
+
+    if (mBGMClock_range_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 0, 0, 0),
+                                   BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 1, 0, 0), BGM_CLOCK_CHECK_ALL)) {
+        if ((info->flag & 4) &&
+            mBGMClock_over_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 0, 0, 0),
+                                      BGM_CLOCK_CHECK_ALL) &&
+            mBGMFieldSchedEv_bl_attr_evdata_get(&mbgm_event_data[16], play) != BGM_BL_ATTRIBUTE_INACTIVE) {
+            info->flag |= 0x20;
+        }
+
+        if ((info->flag & 0x20)) {
+            UNUSED s32 scoped;
+
+            if (mBGMFieldSchedEv_bl_attr_evdata_get(&mbgm_event_data[16], play) == BGM_BL_ATTRIBUTE_INACTIVE) {
+                info->flag &= ~0x20;
+            }
+        }
+
+        if (info->flag & 0x20) {
+            if (mEv_check_status(6, 1)) {
+                eventNow = TRUE;
+            }
+        }
+    } else {
+        info->flag &= ~0x20;
+    }
+
+    if (eventNow) {
+        info->flag |= 1;
+    } else {
+        info->flag &= ~1;
+    }
+}
+
+void mBGMFieldSchedEv_Info_ev_now_set_CountDown_6(BgmFieldScheduleInfo* info, UNUSED BgmEventData* data,
+                                                  Game_Play* play, UNUSED s32 eventStartFlag) {
+    s32 eventNow = FALSE;
+
+    if (mBGMClock_range_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 0, 0, 0),
+                                   BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 1, 0, 0), BGM_CLOCK_CHECK_ALL)) {
+        if ((info->flag & 4) &&
+            mBGMClock_over_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 0, 0, 0),
+                                      BGM_CLOCK_CHECK_ALL) &&
+            mBGMFieldSchedEv_bl_attr_evdata_get(&mbgm_event_data[17], play) != BGM_BL_ATTRIBUTE_INACTIVE) {
+            info->flag |= 0x20;
+        }
+
+        if (info->flag & 0x20) {
+            UNUSED s32 scoped;
+
+            if (mBGMFieldSchedEv_bl_attr_evdata_get(&mbgm_event_data[17], play) == BGM_BL_ATTRIBUTE_INACTIVE) {
+                info->flag &= ~0x20;
+            }
+        }
+
+        if (!(info->flag & 0x20)) {
+            if (mEv_check_status(6, 1)) {
+                eventNow = TRUE;
+            }
+        }
+    } else {
+        info->flag &= ~0x20;
+    }
+
+    if (eventNow) {
+        info->flag |= 1;
+    } else {
+        info->flag &= ~1;
+    }
+}
+
+void mBGMFieldSchedEv_Info_ev_now_set_NewYear01(BgmFieldScheduleInfo* info, UNUSED BgmEventData* data,
+                                                UNUSED Game_Play* play, UNUSED s32 eventStartFlag) {
+    if (mBGMClock_range_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 0, 0, 0),
+                                   BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 18, 0, 0), BGM_CLOCK_CHECK_ALL)) {
+        info->flag |= 1;
+    } else {
+        info->flag &= ~1;
+    }
+}
+
+void mBGMFieldSchedEv_Info_ev_now_set_NewYear02(BgmFieldScheduleInfo* info, UNUSED BgmEventData* data,
+                                                UNUSED Game_Play* play, UNUSED s32 eventStartFlag) {
+    if (mBGMClock_range_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 18, 0, 0),
+                                   BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 2, 0, 0, 0), BGM_CLOCK_CHECK_ALL)) {
+        info->flag |= 1;
+    } else {
+        info->flag &= ~1;
+    }
+}
+
+void mBGMFieldSchedEv_Info_attr_now_set(BgmFieldScheduleInfo* info, Game_Play* play, BgmEventData* data) {
+    info->attribute = BGM_BL_ATTRIBUTE_INACTIVE;
+
+    if ((info->flag & 5) == 5) {
+        s32 attribute = mBGMFieldSchedEv_bl_attr_evdata_get(data, play);
+
+        if (attribute < BGM_BL_ATTRIBUTE_MAX) {
+            info->attribute = attribute;
+        }
+    }
+}
+
+typedef void (*BgmFieldScheduleEventInfoFunc)(BgmFieldScheduleInfo*, BgmEventData*, Game_Play*, s32);
+
+void mBGMFieldSchedEv_info_set(BgmFieldScheduleEvent* schedule, Game_Play* play) {
+    static BgmFieldScheduleEventInfoFunc ev_chk[] = {
+        mBGMFieldSchedEv_Info_ev_now_set_Silence_0,   mBGMFieldSchedEv_Info_ev_now_set_standard,
+        mBGMFieldSchedEv_Info_ev_now_set_standard,    mBGMFieldSchedEv_Info_ev_now_set_standard,
+        mBGMFieldSchedEv_Info_ev_now_set_standard,    mBGMFieldSchedEv_Info_ev_now_set_standard,
+        mBGMFieldSchedEv_Info_ev_now_set_standard,    mBGMFieldSchedEv_Info_ev_now_set_standard,
+        mBGMFieldSchedEv_Info_ev_now_set_standard,    mBGMFieldSchedEv_Info_ev_now_set_standard,
+        mBGMFieldSchedEv_Info_ev_now_set_standard,    mBGMFieldSchedEv_Info_ev_now_set_standard,
+        mBGMFieldSchedEv_Info_ev_now_set_CountDown_1, mBGMFieldSchedEv_Info_ev_now_set_CountDown_2,
+        mBGMFieldSchedEv_Info_ev_now_set_CountDown_3, mBGMFieldSchedEv_Info_ev_now_set_CountDown_4,
+        mBGMFieldSchedEv_Info_ev_now_set_CountDown_5, mBGMFieldSchedEv_Info_ev_now_set_CountDown_6,
+        mBGMFieldSchedEv_Info_ev_now_set_standard,    mBGMFieldSchedEv_Info_ev_now_set_NewYear01,
+        mBGMFieldSchedEv_Info_ev_now_set_NewYear02,
+    };
+
+    BgmFieldScheduleInfo* info;
+    BgmEventData* data;
+    s32 i;
+    s32 edge = mEv_check_status_edge(1);
+    s32 validField = mFI_CheckFieldData() && FI_GET_TYPE(mFI_GetFieldId()) == 0;
+
+    for (i = 0, info = schedule->info, data = mbgm_event_data; i < ARRAY_COUNT(mbgm_event_data); info++, i++, data++) {
+        mBGMFieldSchedEv_Info_old_copy(info);
+        info->flag &= ~4;
+
+        if (validField) {
+            info->flag |= 4;
+        }
+
+        ev_chk[i](info, data, play, edge);
+        mBGMFieldSchedEv_Info_attr_now_set(info, play, data);
+    }
+}
+
+void mBGMFieldSchedEv_Info_ps_delete(UNUSED BgmFieldScheduleInfo* info, BgmEventData* data, s32 flag) {
+    mBGMPsComp_delete_ps_fieldSchedEv(data->num, 0x168);
+
+    if (flag) {
+        s32 num = mBGMPsComp_execute_bgm_num_get();
+
+        if (num == data->num) {
+            mBGMPsComp_search_cf_set_field(data->num, 10);
+        }
+    }
+}
+void mBGMFieldSchedEv_Info_ps_make(BgmFieldScheduleInfo* info, BgmEventData* data, s32 priority) {
+    s32 updateVolumeCtrl =
+        info->attribute != BGM_BL_ATTRIBUTE_INACTIVE && info->priorAttribute == BGM_BL_ATTRIBUTE_INACTIVE;
+    s32 updateVolumeLevel = mbgm_pattern_data[data->eventArea][info->attribute] == 1;
+    s32 crossfade = mBGMPsComp_execute_bgm_num_get() >= 0;
+    u16 stopType = priority == 0 ? (u16)0xA8C : (u16)0x168;
+
+    mBGMPsComp_make_ps_fieldSchedEv(data->num, updateVolumeCtrl, updateVolumeLevel, crossfade, stopType, priority);
+}
+
+void mBGMFieldSchedEv_Info_ps_volume_change(BgmFieldScheduleInfo* info, BgmEventData* data) {
+    s32 flag = mbgm_pattern_data[data->eventArea][info->attribute] == 1;
+
+    mBGMPsComp_volume_change_fieldSchedEv(data->num, TRUE, flag);
+}
+
+void mBGMFieldSchedEv_ps_compose(BgmFieldScheduleEvent* schedule, UNUSED Game_Play* play) {
+    s32 i;
+    s32 nowFlag = 0;
+    s32 priorFlag;
+    BgmFieldScheduleInfo* info;
+    BgmEventData* data;
+    s32 flag = TRUE;
+
+    for (i = 0, info = schedule->info, data = mbgm_event_data; i < ARRAY_COUNT(mbgm_event_data); i++, info++, data++) {
+        nowFlag = (info->flag & 5) == 5 && info->attribute != BGM_BL_ATTRIBUTE_INACTIVE;
+        priorFlag = (info->flag & 10) == 10 && info->priorAttribute != BGM_BL_ATTRIBUTE_INACTIVE;
+
+        if (!nowFlag && priorFlag) {
+            mBGMFieldSchedEv_Info_ps_delete(info, data, flag);
+        }
+
+        if (nowFlag && !priorFlag) {
+            if (data && data) {}
+            mBGMFieldSchedEv_Info_ps_make(info, data, i);
+        }
+
+        if (nowFlag && priorFlag) {
+            s32 nowVol = mbgm_pattern_data[data->eventArea][info->attribute];
+            s32 priorVol = mbgm_pattern_data[data->eventArea][info->priorAttribute];
+
+            if (nowVol != priorVol && nowVol != 0 && priorVol != 0 && data->num != 255) {
+                mBGMFieldSchedEv_Info_ps_volume_change(info, data);
+            }
+        }
+
+        if (flag && priorFlag) {
+            flag = FALSE;
+        }
+    }
+}
+void mBGMFieldSchedEv_sp_flag(BgmFieldScheduleEvent* schedule) {
+    BgmFieldScheduleInfo* info0 = &schedule->info[16];
+    BgmFieldScheduleInfo* info1 = &schedule->info[17];
+
+    if ((((info0->flag & 5) == 5 && info0->attribute != BGM_BL_ATTRIBUTE_INACTIVE) ||
+         ((info1->flag & 5) == 5 && info1->attribute != BGM_BL_ATTRIBUTE_INACTIVE)) &&
+        mBGMClock_range_time_check(&M_bgm.clock, BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 0, 0, 0),
+                                   BGM_RTC_TIME_TO_BGM_TIME(lbRTC_JANUARY, 1, 0, 1, 0), BGM_CLOCK_CHECK_ALL)) {
+        mBGMTime_new_year_ev_flag_set();
+    } else {
+        mBGMTime_new_year_ev_flag_clr();
+    }
+}
+
+void mBGMFieldSchedEv_move(BgmFieldScheduleEvent* schedule, Game_Play* play) {
+    mBGMFieldSchedEv_info_set(schedule, play);
+    mBGMFieldSchedEv_ps_compose(schedule, play);
+    mBGMFieldSchedEv_sp_flag(schedule);
+}
+
+void mBGMFieldSchedEv_ct(BgmFieldScheduleEvent* schedule) {
+    s32 i;
+    bzero(schedule, sizeof(BgmFieldScheduleEvent));
+
+    for (i = 0; i < ARRAY_COUNT(schedule->info); i++) {
+        schedule->info[i].priorAttribute = BGM_BL_ATTRIBUTE_INACTIVE;
+        schedule->info[i].attribute = BGM_BL_ATTRIBUTE_INACTIVE;
+    }
+}
+
+u8 mBGMFieldNorm_bgm_num_get(s32 hour) {
+    static u8 bgm_table[lbRTC_HOURS_PER_DAY] = { 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
+                                                 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 };
+
+    return bgm_table[hour];
+}
+
+void mBGMFieldNorm_elem_set(BgmFieldNorm* norm) {
+    s32 hour = common_data.time.rtcTime.hour % 24;
+
+    mBGMElem_default_set(&norm->element);
+    norm->element.num = mBGMFieldNorm_bgm_num_get(hour);
+}
+
+void mBGMFieldNorm_make_bgm(BgmFieldNorm* norm, UNUSED Game_Play* play) {
+    if (norm->element.num == 255) {
+        mBGMFieldNorm_elem_set(norm);
+        mBGMPsComp_make_ps_fieldNorm(norm->element.num, 0x168);
+    }
+}
+
+void mBGMFieldNorm_delete_bgm(BgmFieldNorm* norm) {
+    if (norm->element.num != 255) {
+        mBGMPsComp_delete_ps_fieldNorm(norm->element.num, norm->element.stopType0);
+        norm->element.num = 255;
+    }
+}
+
+void mBGMFieldNorm_move(BgmFieldNorm* norm, Game_Play* play) {
+    if (mBGMClock_over_time_check(&M_bgm.clock, 0, BGM_CLOCK_CHECK_MIN | BGM_CLOCK_CHECK_SEC) && mFI_CheckFieldData() &&
+        FI_GET_TYPE(mFI_GetFieldId()) == 0) {
+        norm->deleteFlag = TRUE;
+        norm->makeFlag = TRUE;
+    }
+
+    if (norm->deleteFlag) {
+        mBGMFieldNorm_delete_bgm(norm);
+    }
+
+    if (norm->makeFlag) {
+        mBGMFieldNorm_make_bgm(norm, play);
+    }
+
+    norm->makeFlag = FALSE;
+    norm->deleteFlag = FALSE;
+}
+
+void mBGMFieldNorm_make_req() {
+    M_bgm.fieldNorm.makeFlag = TRUE;
+}
+
+void mBGMFieldNorm_delete_req() {
+    M_bgm.fieldNorm.deleteFlag = TRUE;
+}
+
+void mBGMFieldNorm_ct(BgmFieldNorm* norm) {
+    bzero(norm, sizeof(BgmFieldNorm));
+    mBGMElem_default_set(&norm->element);
+}
+
+void mBGMPs_counter_dec(BgmPS* ps) {
+    if (ps->counter > 0) {
+        ps->counter--;
+
+        if (ps->counter == 0) {
+            ps->cfFlags |= 1;
+        }
+    }
+}
+
+void mBGMPsComp_ps_remove(BgmPSComp* psComp, s32 removePos) {
+    if (removePos >= 0 && removePos < BGM_PS_MAX) {
+        if (removePos < psComp->psNum && psComp->psNum > 0) {
+            s32 i;
+            s32 max = psComp->psNum - 1;
+
+            for (i = removePos; i < max; i++) {
+                psComp->ps[i] = psComp->ps[i + 1];
+            }
+
+            bzero(&psComp->ps[max], sizeof(BgmPS));
+            psComp->psNum = max;
+        }
+    }
+}
+
+s32 mBGMPsComp_search_insert_pos_kategorie(BgmPSComp* psComp, s32 category, u8 priority) {
+    s32 max = psComp->psNum;
+    s32 res = -1;
+
+    if (max < BGM_PS_MAX) {
+        s32 i = 0;
+        BgmPS* ps = psComp->ps;
+
+        res = max;
+        for (; i < max; i++, ps++) {
+            if ((category == ps->category && priority < ps->priority) || category < ps->category) {
+                res = i;
+                break;
+            }
+        }
+    } else {
+        res = -1;
+    }
+
+    return res;
+}
+
+s32 mBGMPsComp_search_pos_kategorie_bgm_num(BgmPSComp* psComp, s32 category, u8 num, s32 counterFlag, s32 delPass) {
+    BgmPS* ps;
+    s32 validCategory = category < 12;
+    s32 bgmIsReset = num != 255;
+    s32 res = -1;
+    s32 mask = delPass != 0 ? 0 : 1;
+
+    if (validCategory || bgmIsReset) {
+        s32 max = psComp->psNum;
+        s32 i = 0;
+
+        for (ps = psComp->ps; i < max; i++, ps++) {
+            if ((!validCategory || ps->category == category) && (bgmIsReset == 0 || ps->element.num == num) &&
+                (counterFlag == FALSE || (ps->counter < 0 && (ps->cfFlags & 0x80) == 0)) &&
+                ((ps->cfFlags & mask) == 0)) {
+                res = i;
+                break;
+            }
+        }
+    }
+
+    return res;
+}
+
+void mBGMPsComp_shift_behind(BgmPSComp* psComp, s32 shiftIdx) {
+    if (psComp->psNum != 0) {
+        s32 i;
+
+        for (i = psComp->psNum - 1; i >= shiftIdx; i--) {
+            bcopy(&psComp->ps[i], &psComp->ps[i + 1], sizeof(BgmPS));
+        }
+    }
+
+    bzero(&psComp->ps[shiftIdx], sizeof(BgmPS));
+    psComp->psNum++;
+}
+
+void mBGMPsComp_all_ps_bitclr(BgmPSComp* psComp, u8 bits) {
+    BgmPS* ps;
+    s32 max = psComp->psNum;
+    s32 i = 0;
+
+    for (ps = psComp->ps; i < max; i++, ps++) {
+        ps->cfFlags &= ~bits;
+    }
+}
+
+s32 mBGMPsComp_execute_ps_pos_get(BgmPSComp* psComp) {
+    BgmPS* ps;
+    s32 idx = -1;
+    s32 max = psComp->psNum;
+    s32 i = 0;
+
+    for (ps = psComp->ps; i < max; i++, ps++) {
+        if ((ps->cfFlags & 4)) {
+            idx = i;
+            break;
+        }
+    }
+
+    return idx;
+}
+
+BgmPS* mBGMPsComp_high_ps_not_delete(BgmPSComp* psComp, s32 maxPos) {
+    BgmPS* ps;
+    BgmPS* highPs = NULL;
+    s32 max = maxPos;
+    s32 i = 0;
+
+    for (ps = psComp->ps; i < max; i++, ps++) {
+        if (!(ps->cfFlags & 1)) {
+            highPs = ps;
+            break;
+        }
+    }
+
+    return highPs;
+}
+
+void mBGMPsComp_main_req_stop(BgmPSComp* psComp) {
+    s32 executePos;
+    BgmPS* ps;
+    BgmPS* highPs;
+
+    executePos = mBGMPsComp_execute_ps_pos_get(psComp);
+    if (executePos >= 0) {
+        ps = psComp->ps + executePos;
+
+        if ((ps->cfFlags & 0x40) == 0) {
+            if (executePos > 0) {
+                highPs = mBGMPsComp_high_ps_not_delete(psComp, executePos);
+
+                if (highPs != NULL) {
+                    psComp->stop.requestFlag = TRUE;
+                    psComp->stop.type = highPs->element.stopType1;
+                    return;
+                }
+            }
+
+            if ((ps->cfFlags & 0x1) && (ps->cfFlags & 0x100) == 0) {
+                psComp->stop.requestFlag = TRUE;
+                psComp->stop.type = ps->element.stopType0;
+            }
+        }
+    }
+}
+
+void mBGMPsComp_main_remove(BgmPSComp* psComp) {
+    BgmPS* ps;
+    s32 i;
+
+    for (i = psComp->psNum - 1, ps = &psComp->ps[i]; i >= 0; i--, ps--) {
+        if ((ps->cfFlags & 1)) {
+            ps->cfFlags &= ~1;
+            mBGMPsComp_ps_remove(psComp, i);
+        }
+    }
+}
+
+void mBGMPsComp_main_req_start(BgmPSComp* psComp) {
+    if (psComp->psNum > 0) {
+        BgmPS* ps = &psComp->ps[0];
+
+        if ((ps->cfFlags & 4) == 0) {
+            if ((ps->cfFlags & 0x40) == 0) {
+                psComp->start.requestFlag = TRUE;
+
+                psComp->start.flags = ps->cfFlags & 0x8 ? 1 : 0;
+                psComp->start.num = ps->element.num;
+
+                if (mBGM_check_MD(ps->element.num) == FALSE) {
+                    ps->cfFlags |= 2;
+                }
+            }
+
+            mBGMPsComp_all_ps_bitclr(psComp, 4);
+            ps->cfFlags |= 4;
+        }
+
+        mBGMPsComp_all_ps_bitclr(psComp, 8);
+    }
+}
+
+void mBGMPsComp_main_req_pause(BgmPSComp* psComp) {
+    if (psComp->pauseState == 1 || psComp->pauseState == 3) {
+        psComp->pause.mode = 1;
+        psComp->pause.requestFlag = TRUE;
+    } else if (psComp->pauseState == 2) {
+        psComp->pause.mode = 2;
+        psComp->pause.requestFlag = TRUE;
+    } else if (psComp->pauseState == 5) {
+        psComp->pause.mode = 0;
+        psComp->pause.requestFlag = TRUE;
+    }
+}
+
+void mBGMPsComp_main_req_md(BgmPSComp* psComp) {
+    if (psComp->md.moveFlag) {
+        psComp->md.requestFlag = TRUE;
+    }
+}
+
+void mBGMPsComp_main_md_move(BgmPSComp* psComp) {
+    BgmPSMd* md = &psComp->md;
+
+    if (md->deleteFlag) {
+        md->moveFlag = FALSE;
+        md->deleteFlag = FALSE;
+    }
+
+    if (md->makeFlag) {
+        md->moveFlag = TRUE;
+        md->makeFlag = FALSE;
+    }
+}
+
+void mBGMPsComp_main_req_volume_ps(BgmPSComp* psComp) {
+    if (psComp->psNum > 0) {
+        if ((psComp->ps[0].cfFlags & 2)) {
+            if ((psComp->ps[0].cfFlags & 0x10)) {
+                psComp->volume.psVolumeMoveCounter = 90;
+            } else {
+                psComp->volume.psVolumeMoveCounter = 0;
+            }
+
+            if ((psComp->ps[0].cfFlags & 0x20)) {
+                psComp->volume.psVolume = 0.5f;
+            } else {
+                psComp->volume.psVolume = 1.0f;
+            }
+
+            psComp->volume.psRequestFlag = TRUE;
+        }
+
+        mBGMPsComp_all_ps_bitclr(psComp, 0x12);
+    }
+
+    if (mBGMPsComp_execute_bgm_num_get() < 0) {
+        psComp->volume.psVolume = -1.0f;
+    }
+}
+
+void func_8005D2A4_jp(BgmPSComp* psComp) {
+    if (psComp->fishInsectState == 1) {
+        psComp->fishInsectState = 2;
+        psComp->volume.fishingInsectVolume = 0.65f;
+        psComp->volume.fishingInsectVolumeMoveCounter = 100;
+        psComp->volume.fishingInsectRequestFlag = TRUE;
+    } else if (psComp->fishInsectState == 3) {
+        psComp->fishInsectState = 0;
+        psComp->volume.fishingInsectVolume = -1.0f;
+        psComp->volume.fishingInsectVolumeMoveCounter = 17;
+
+        if (psComp->psNum <= 0 || mBGM_check_MD(psComp->ps[0].element.num) == FALSE) {
+            psComp->volume.fishingInsectRequestFlag = TRUE;
+        }
+    }
+}
+
+void mBGMPsComp_main_req_volume_talk(BgmPSComp* psComp) {
+    if (psComp->talkState == 1) {
+        psComp->talkState = 2;
+        psComp->volume.talkVolume = 0.7f;
+        psComp->volume.talkRequestFlag = TRUE;
+    } else if (psComp->talkState == 3) {
+        psComp->talkState = 0;
+        psComp->volume.talkVolume = -1.0f;
+
+        if (psComp->psNum <= 0 || mBGM_check_MD(psComp->ps[0].element.num) == FALSE) {
+            psComp->volume.talkRequestFlag = TRUE;
+        }
+    }
+}
+
+void mBGMPsComp_main_req_volume_pause(BgmPSComp* psComp) {
+    if (psComp->pauseState == 1) {
+        psComp->pauseState = 4;
+        psComp->volume.pauseVolume = 0.5f;
+        psComp->volume.pauseVolumeMoveCounter = 2;
+        psComp->volume.pauseRequestFlag = TRUE;
+    } else if (psComp->pauseState == 2) {
+        psComp->pauseState = 4;
+        psComp->volume.pauseVolume = 0.0f;
+        psComp->volume.pauseVolumeMoveCounter = 2;
+        psComp->volume.pauseRequestFlag = TRUE;
+    } else if (psComp->pauseState == 3) {
+        psComp->pauseState = 4;
+        psComp->volume.pauseVolume = 0.5f;
+        psComp->volume.pauseVolumeMoveCounter = 2;
+        psComp->volume.pauseRequestFlag = TRUE;
+    } else if (psComp->pauseState == 5) {
+        psComp->pauseState = 0;
+        psComp->volume.pauseVolume = -1.0f;
+        psComp->volume.pauseVolumeMoveCounter = 2;
+
+        if (psComp->psNum <= 0 || mBGM_check_MD(psComp->ps[0].element.num) == FALSE) {
+            psComp->volume.pauseRequestFlag = TRUE;
+        }
+    }
+}
+void mBGMPsComp_main_req_volume(BgmPSComp* psComp) {
+    f32 psVolume;
+    f32 fishInsectVolume;
+    f32 talkVolume;
+    f32 pauseVolume;
+    f32 finalVolume;
+    u16 finalVolumeMoveCounter;
+    BgmPS* ps = &psComp->ps[0];
+
+    s32 ignoreTalk;
+    s32 ignoreFishInsect;
+    BgmPSVolume* volume;
+    f32 psVolumeTemp;
+
+    volume = &psComp->volume;
+
+    ignoreTalk = psComp->psNum > 0 ? mBGM_check_ignore_talk_volume(ps->element.num) : FALSE;
+    ignoreFishInsect = psComp->psNum > 0 ? func_8005ACA8_jp(ps->element.num) : FALSE;
+
+    mBGMPsComp_main_req_volume_ps(psComp);
+    func_8005D2A4_jp(psComp);
+    mBGMPsComp_main_req_volume_talk(psComp);
+    mBGMPsComp_main_req_volume_pause(psComp);
+
+    psVolumeTemp = volume->psVolume;
+    psVolume = psVolumeTemp;
+
+    if (psVolumeTemp < 0.0f) {
+        fishInsectVolume = -1.0f;
+        talkVolume = -1.0f;
+        pauseVolume = -1.0f;
+    } else {
+        fishInsectVolume =
+            (volume->fishingInsectVolume < 0.0f || ignoreFishInsect) ? psVolume : volume->fishingInsectVolume;
+
+        talkVolume = (volume->talkVolume < 0.0f || ignoreTalk) ? fishInsectVolume : volume->talkVolume;
+
+        pauseVolume = (volume->pauseVolume < 0.0f) ? talkVolume : volume->pauseVolume;
+    }
+
+    finalVolume = -1.0f;
+    finalVolumeMoveCounter = 0;
+
+    if (volume->psRequestFlag) {
+        finalVolume = psVolume;
+        finalVolumeMoveCounter = volume->psVolumeMoveCounter;
+    }
+
+    if (volume->fishingInsectRequestFlag && !ignoreFishInsect) {
+        finalVolume = fishInsectVolume;
+        finalVolumeMoveCounter = volume->fishingInsectVolumeMoveCounter;
+    }
+
+    if (volume->talkRequestFlag && !ignoreTalk) {
+        finalVolume = talkVolume;
+        finalVolumeMoveCounter = 30;
+    }
+
+    if (volume->pauseRequestFlag) {
+        finalVolume = pauseVolume;
+        finalVolumeMoveCounter = volume->pauseVolumeMoveCounter;
+    }
+
+    if (psComp->pauseState == 4) {
+        if ((finalVolume < 0) == FALSE) {
+            finalVolume = pauseVolume;
+        }
+    } else if (psComp->talkState == 2) {
+        if ((finalVolume < 0) == FALSE) {
+            finalVolume = talkVolume;
+        }
+    } else if (psComp->fishInsectState == 2) {
+        if ((finalVolume < 0) == FALSE) {
+            finalVolume = fishInsectVolume;
+        }
+    }
+
+    if ((finalVolume < 0.0f) == FALSE) {
+        volume->mainVolume = finalVolume;
+        volume->mainVolumeMoveCounter = finalVolumeMoveCounter;
+        volume->mainRequestFlag = TRUE;
+    }
+
+    volume->psRequestFlag = FALSE;
+    volume->fishingInsectRequestFlag = FALSE;
+    volume->talkRequestFlag = FALSE;
+    volume->pauseRequestFlag = FALSE;
+}
+
+void mBGMPsComp_MDPlayerPos_main_inform_sound(BgmPSMd* md) {
+    if (md->requestFlag) {
+        sAdo_MDPlayerPos(&md->pos, md->angle, md->mdType, md->ongenNum);
+        md->requestFlag = FALSE;
+    }
+}
+
+void mBGMPsComp_Arm_main_inform_sound(BgmPSArm* arm) {
+    if (arm->requestFlag) {
+        if (mBGMPsComp_execute_bgm_num_get() == 43) {
+            sAdos_TTKK_ARM(arm->armState);
+
+            if (arm->armState == 0) {
+                mBGMPsComp_arm_delete();
+            }
+        } else {
+            mBGMPsComp_arm_delete();
+        }
+    }
+}
+
+void mBGMPsComp_Stop_main_inform_sound(BgmPSStop* stop) {
+    if (stop->requestFlag) {
+        sAdo_BgmStop(stop->type);
+        stop->requestFlag = FALSE;
+    }
+}
+
+void mBGMPsComp_Start_main_inform_sound(BgmPSStart* start) {
+    if (start->requestFlag) {
+        if (start->flags != 0) {
+            sAdo_BgmCrossfadeStart(start->num);
+        } else {
+            sAdo_BgmStart(start->num);
+
+            if (start->num == 43) {
+                if (common_data.save.sceneNo == SCENE_PLAYERSELECT_2) {
+                    mBGMPsComp_arm_make(1);
+                } else {
+                    mBGMPsComp_arm_make(0);
+                }
+            }
+        }
+
+        start->requestFlag = FALSE;
+    }
+}
+
+void mBGMPsComp_Volume_main_inform_sound(BgmPSVolume* volume) {
+    if (volume->mainRequestFlag) {
+        sAdo_BGMVolume(volume->mainVolume, volume->mainVolumeMoveCounter);
+        volume->mainRequestFlag = FALSE;
+    }
+}
+
+void mBGMPsComp_Pause_main_inform_sound(BgmPSPause* pause) {
+    if (pause->requestFlag) {
+        sAdo_Pause(pause->mode);
+        pause->requestFlag = FALSE;
+    }
+}
+
+void mBGMPsComp_main_inform_sound(BgmPSComp* psComp) {
+    mBGMPsComp_MDPlayerPos_main_inform_sound(&psComp->md);
+    mBGMPsComp_Arm_main_inform_sound(&psComp->arm);
+    mBGMPsComp_Stop_main_inform_sound(&psComp->stop);
+    mBGMPsComp_Start_main_inform_sound(&psComp->start);
+    mBGMPsComp_Pause_main_inform_sound(&psComp->pause);
+    mBGMPsComp_Volume_main_inform_sound(&psComp->volume);
+}
+
+void mBGMPsComp_main_counter_dec(BgmPSComp* psComp) {
+    BgmPS* ps;
+    s32 i;
+    s32 max = psComp->psNum;
+
+    for (i = 0, ps = psComp->ps; i < max; i++, ps++) {
+        mBGMPs_counter_dec(ps);
+    }
+}
+
+void mBGMPsComp_main_fo_check(BgmPSComp* psComp) {
+    BgmPS* ps;
+    s32 i;
+    s32 max = psComp->psNum;
+
+    for (i = 0, ps = psComp->ps; i < max; i++, ps++) {
+        if (ps->cfFlags & 0x80) {
+            s32 executePos = mBGMPsComp_execute_ps_pos_get(psComp);
+
+            if ((executePos >= i || executePos < 0) || (psComp->ps[executePos].element.num == 255) ||
+                (psComp->ps[executePos].cfFlags & 0x40)) {
+                if (sAdo_BgmFadeoutCheck() == FALSE) {
+                    continue;
+                }
+            }
+
+            ps->cfFlags &= ~0x80;
+            ps->cfFlags |= 1;
+        }
+    }
+}
+
+void mBGMPsComp_main_lost(BgmPSComp* psComp) {
+    BgmPS* ps;
+    s32 i;
+    s32 max = psComp->psNum;
+
+    for (i = 0, ps = psComp->ps; i < max; i++, ps++) {
+        if ((ps->cfFlags & 0x100)) {
+            ps->cfFlags |= 1;
+        }
+    }
+}
+
+s32 mBGMPsComp_make_ps(BgmPSComp* psComp, BgmElement* element, s32 category, s16 counter, u16 cfFlags, u8 priority) {
+    s32 pos = mBGMPsComp_search_insert_pos_kategorie(psComp, category, priority);
+
+    if (pos >= 0) {
+        BgmPS* dstPs = &psComp->ps[pos];
+
+        mBGMPsComp_shift_behind(psComp, pos);
+        bcopy(element, &dstPs->element, sizeof(BgmElement));
+        dstPs->category = category;
+        dstPs->counter = counter;
+        dstPs->cfFlags = cfFlags;
+        dstPs->priority = priority;
+    }
+
+    return pos;
+}
+
+void _mBGMPsComp_make_ps_fanfare(u8 num, u16 stopType) {
+    UNUSED s32 pad;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.num = num;
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(&M_bgm.psComp, &element, 0, -1, 0, 0xFF);
+}
+
+void mBGMPsComp_make_ps_fanfare(u8 num, u16 stopType) {
+    _mBGMPsComp_make_ps_fanfare(num, stopType);
+}
+
+void _mBGMPsComp_make_ps_lost_fanfare(u8 num, u16 stopType) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.num = num;
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 0, -1, 0x100, 0xFF);
+}
+
+void mBGMPsComp_make_ps_lost_fanfare(u8 num, u16 stopType) {
+    _mBGMPsComp_make_ps_lost_fanfare(num, stopType);
+}
+
+void _mBGMPsComp_make_ps_wipe(u16 stopType) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    if (mBGMForce_wipe_ps_make_permit(&M_bgm.force) &&
+        mBGMPsComp_search_pos_kategorie_bgm_num(psComp, 1, 255, FALSE, FALSE) < 0) {
+        mBGMElem_default_set(&element);
+        element.stopType1 = stopType;
+        mBGMPsComp_make_ps(&M_bgm.psComp, &element, 1, -1, 0x40, 0xFF);
+    }
+}
+
+void mBGMPsComp_make_ps_wipe(u16 stopType) {
+    _mBGMPsComp_make_ps_wipe(stopType);
+}
+
+void _mBGMPsComp_make_ps_quiet(u16 stopType) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 2, -1, 0x40, 0xFF);
+}
+
+void mBGMPsComp_make_ps_quiet(u16 stopType) {
+    _mBGMPsComp_make_ps_quiet(stopType);
+}
+
+void _mBGMPsComp_make_ps_co_quiet(u16 stopType, s16 counter) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 2, counter, 0x40, 0xFF);
+}
+
+void mBGMPsComp_make_ps_co_quiet(u16 stopType, s16 counter) {
+    _mBGMPsComp_make_ps_co_quiet(stopType, counter);
+}
+
+void _mBGMPsComp_make_ps_demo(u8 num, u16 stopType) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.num = num;
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 3, -1, 0, 0xFF);
+}
+
+void mBGMPsComp_make_ps_demo(u8 num, u16 stopType) {
+    _mBGMPsComp_make_ps_demo(num, stopType);
+}
+
+void _mBGMPsComp_make_ps_happening(u8 num, u16 stopType) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.num = num;
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 4, -1, 0, 0xFF);
+}
+
+void mBGMPsComp_make_ps_happening(u8 num, u16 stopType) {
+    _mBGMPsComp_make_ps_happening(num, stopType);
+}
+
+void mBGMPsComp_make_ps_quietRoom(u16 stopType) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 5, -1, 0x40, 0xFF);
+}
+
+void _mBGMPsComp_make_ps_room(u8 num, u16 stopType) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.num = num;
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 6, -1, 0, 0xFF);
+}
+
+void mBGMPsComp_make_ps_room(u8 num, u16 stopType) {
+    _mBGMPsComp_make_ps_room(num, stopType);
+}
+
+void mBGMPsComp_make_ps_time() {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.stopType1 = 0x870;
+    mBGMPsComp_make_ps(psComp, &element, 7, -1, 0x40, 0xFF);
+}
+
+void _mBGMPsComp_make_ps_quietField(u16 stopType) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 8, -1, 0x40, 0xFF);
+}
+
+void mBGMPsComp_make_ps_quietField(u16 stopType) {
+    _mBGMPsComp_make_ps_quietField(stopType);
+}
+
+void _mBGMPsComp_make_ps_fc_quietField(u16 stopType) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 8, -1, 0xC0, 0xFF);
+}
+
+void mBGMPsComp_make_ps_fc_quietField(u16 stopType) {
+    _mBGMPsComp_make_ps_fc_quietField(stopType);
+}
+
+void _mBGMPsComp_make_ps_fieldSuddenEv(u8 num, u16 stopType, u8 priority) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.num = num;
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 9, -1, 0, priority);
+}
+
+void mBGMPsComp_make_ps_fieldSuddenEv(u8 num, u16 stopType, u8 priority) {
+    _mBGMPsComp_make_ps_fieldSuddenEv(num, stopType, priority);
+}
+
+void mBGMPsComp_make_ps_fieldSchedEv(u8 num, s32 updateVolumeMoveCounter, s32 updateVolumeFlag, s32 cfFlag,
+                                     u16 stopType, u8 priority) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+    u16 flags;
+
+    mBGMElem_default_set(&element);
+    element.num = num;
+    element.stopType1 = stopType;
+    flags = 0;
+
+    if (updateVolumeMoveCounter) {
+        flags |= 0x10;
+    }
+
+    if (updateVolumeFlag) {
+        flags |= 0x20;
+    }
+
+    if (cfFlag) {
+        flags |= 8;
+    }
+
+    if (num == 255) {
+        flags |= 0x40;
+    }
+
+    mBGMPsComp_make_ps(psComp, &element, 10, -1, flags, priority);
+}
+
+void mBGMPsComp_make_ps_fieldNorm(u8 num, u16 stopType) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    BgmElement element;
+
+    mBGMElem_default_set(&element);
+    element.num = num;
+    element.stopType1 = stopType;
+    mBGMPsComp_make_ps(psComp, &element, 11, -1, 0, 0xFF);
+}
+
+void mBGMPsComp_delete_ps(BgmPSComp* psComp, s32 category, u8 num, u16 stopType, s32 counterFlag) {
+    s32 searchNum = mBGMPsComp_search_pos_kategorie_bgm_num(psComp, category, num, counterFlag, FALSE);
+
+    if (searchNum >= 0 && searchNum < psComp->psNum) {
+        psComp->ps[searchNum].cfFlags |= 1;
+        psComp->ps[searchNum].element.stopType0 = stopType;
+    }
+}
+
+void _mBGMPsComp_delete_ps_fanfare(u8 num, u16 stopType) {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 0, num, stopType, FALSE);
+}
+
+void mBGMPsComp_delete_ps_fanfare(u8 num, u16 stopType) {
+    _mBGMPsComp_delete_ps_fanfare(num, stopType);
+}
+
+void mBGMPsComp_delete_ps_wipe() {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 1, 255, 0x168, FALSE);
+}
+
+void _mBGMPsComp_delete_ps_quiet() {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 2, 255, 0x168, TRUE);
+}
+
+void mBGMPsComp_delete_ps_quiet() {
+    _mBGMPsComp_delete_ps_quiet();
+}
+
+void _mBGMPsComp_delete_ps_demo(u8 num, u16 stopType) {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 3, num, stopType, FALSE);
+}
+
+void mBGMPsComp_delete_ps_demo(u8 num, u16 stopType) {
+    _mBGMPsComp_delete_ps_demo(num, stopType);
+}
+
+void _mBGMPsComp_delete_ps_happening(u8 num, u16 stopType) {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 4, num, stopType, FALSE);
+}
+
+void mBGMPsComp_delete_ps_happening(u8 num, u16 stopType) {
+    _mBGMPsComp_delete_ps_happening(num, stopType);
+}
+
+void mBGMPsComp_delete_ps_quietRoom() {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 5, 255, 0x168, TRUE);
+}
+
+void _mBGMPsComp_delete_ps_room(u8 num, u16 stopType) {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 6, num, stopType, FALSE);
+}
+
+void mBGMPsComp_delete_ps_room(u8 num, u16 stopType) {
+    _mBGMPsComp_delete_ps_room(num, stopType);
+}
+
+void mBGMPsComp_delete_ps_time() {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 7, 255, 0x168, FALSE);
+}
+
+void _mBGMPsComp_delete_ps_quietField() {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 8, 255, 0x168, TRUE);
+}
+
+void mBGMPsComp_delete_ps_quietField() {
+    _mBGMPsComp_delete_ps_quietField();
+}
+
+void _mBGMPsComp_delete_ps_fieldSuddenEv(u8 num, u16 stopType) {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 9, num, stopType, FALSE);
+}
+
+void mBGMPsComp_delete_ps_fieldSuddenEv(u8 num, u16 stopType) {
+    _mBGMPsComp_delete_ps_fieldSuddenEv(num, stopType);
+}
+
+void mBGMPsComp_delete_ps_fieldSchedEv(u8 num, u16 stopType) {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 10, num, stopType, FALSE);
+}
+
+void mBGMPsComp_delete_ps_fieldNorm(u8 num, u16 stopType) {
+    mBGMPsComp_delete_ps(&M_bgm.psComp, 11, num, stopType, FALSE);
+}
+
+void mBGMPsComp_volume_change_fieldSchedEv(u8 num, s32 updateVolumeCounter, s32 updateVolumeLevel) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    s32 posNum = mBGMPsComp_search_pos_kategorie_bgm_num(psComp, 10, num, FALSE, FALSE);
+
+    if (posNum >= 0) {
+        BgmPS* ps = &psComp->ps[posNum];
+
+        if (updateVolumeCounter) {
+            ps->cfFlags |= 0x10;
+        }
+
+        if (updateVolumeLevel) {
+            ps->cfFlags |= 0x20;
+        } else {
+            ps->cfFlags &= ~0x20;
+        }
+
+        ps->cfFlags |= 2;
+    }
+}
+
+void mBGMPsComp_search_cf_set_field(u8 num, s32 category) {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    s32 posNum = mBGMPsComp_search_pos_kategorie_bgm_num(psComp, category, num, FALSE, TRUE);
+
+    if (posNum >= 0) {
+        s32 i;
+
+        for (i = posNum + 1; i < psComp->psNum; i++) {
+            if (psComp->ps[i].category == 9 || psComp->ps[i].category == 10 || psComp->ps[i].category == 11) {
+                psComp->ps[i].cfFlags |= 0x18;
+            }
+        }
+    }
+}
+
+void func_8005E9B4_jp() {
+    M_bgm.psComp.fishInsectState = 1;
+}
+
+void func_8005E9C8_jp() {
+    M_bgm.psComp.fishInsectState = 3;
+}
+
+void mBGMPsComp_volume_talk_start() {
+    M_bgm.psComp.talkState = 1;
+}
+
+void mBGMPsComp_volume_talk_end() {
+    BgmPSComp* psComp = &M_bgm.psComp;
+
+    if (psComp->talkState != 0) {
+        psComp->talkState = 3;
+    }
+}
+
+void mBGMPsComp_pause(s32 state) {
+    M_bgm.psComp.pauseState = state;
+}
+
+void mBGMPsComp_MDPlayerPos_make() {
+    M_bgm.psComp.md.makeFlag = TRUE;
+}
+
+void mBGMPsComp_MDPlayerPos_delete() {
+    M_bgm.psComp.md.deleteFlag = TRUE;
+}
+
+void mBGMPsComp_MDPlayerPos_param_set(xyz_t* pos, u16 angle, u16 mdType, u32 ongenNum) {
+    BgmPSMd* md;
+
+    md = &M_bgm.psComp.md;
+
+    xyz_t_move(&md->pos, pos);
+    md->angle = angle;
+    md->mdType = mdType;
+    md->ongenNum = ongenNum;
+}
+
+void mBGMPsComp_scene_mode(u8 mode) {
+    sAdo_SceneMode(mode);
+}
+
+void mBGMPsComp_arm_make(s32 state) {
+    BgmPSArm* arm = &M_bgm.psComp.arm;
+
+    arm->requestFlag = TRUE;
+    arm->armState = state;
+}
+
+void mBGMPsComp_arm_delete() {
+    BgmPSArm* arm = &M_bgm.psComp.arm;
+
+    arm->requestFlag = FALSE;
+    arm->armState = 0;
+}
+
+s32 mBGMPsComp_execute_bgm_num_get() {
+    BgmPSComp* psComp = &M_bgm.psComp;
+    s32 pos = mBGMPsComp_execute_ps_pos_get(psComp);
+
+    if (pos >= 0 && psComp->ps[pos].element.num != 255 && (psComp->ps[pos].cfFlags & 0x40) == 0) {
+        return psComp->ps[pos].element.num;
+    }
+
+    return -1;
+}
+
+void mBGMPsComp_ct(BgmPSComp* psComp) {
+    BgmPSVolume* volume = &psComp->volume;
+
+    bzero(psComp, sizeof(BgmPSComp));
+
+    volume->mainVolume = -1.0f;
+    volume->mainVolumeMoveCounter = 0;
+    volume->psVolume = -1.0f;
+    volume->psVolumeMoveCounter = 0;
+    volume->fishingInsectVolume = -1.0f;
+    volume->fishingInsectVolumeMoveCounter = 100;
+    volume->talkVolume = -1.0f;
+    volume->pauseVolume = -1.0f;
+    volume->pauseVolumeMoveCounter = 2;
+}
+
+s32 mBGMForce_wipe_ps_make_permit(BgmForce* force) {
+    return force->roomNonstop == 0;
+}
+
+void mBGMForce_move_inform(BgmForce* force) {
+    if (force->inform == 1) {
+        s32 checkField = mFI_CheckFieldData();
+
+        if (checkField == FALSE || (checkField != FALSE && FI_GET_TYPE(mFI_GetFieldId()) != 0)) {
+            force->flag = TRUE;
+            mBGMPsComp_make_ps_wipe(0x428A);
+        }
+
+        force->inform = 2;
+    } else if (force->inform == 3) {
+        force->inform = 4;
+    } else if (force->inform == 5) {
+        if (force->flag) {
+            mBGMPsComp_make_ps_wipe(0x28A);
+        }
+
+        force->inform = 6;
+    } else if (force->inform == 7) {
+        force->inform = 0;
+        force->flag = FALSE;
+    }
+}
+
+void mBGMForce_move_room_nonstop(BgmForce* force) {
+    if (force->roomNonstop == 1) {
+        force->roomNonstop = 2;
+    } else if (force->roomNonstop == 3) {
+        force->roomNonstop = 0;
+    }
+}
+
+void mBGMForce_move(BgmForce* force) {
+    mBGMForce_move_inform(force);
+    mBGMForce_move_room_nonstop(force);
+}
+
+void mBGMForce_ct(BgmForce* force) {
+    bzero(force, sizeof(BgmForce));
+}
+
+void mBGMForce_inform_cleanup(BgmForce* force) {
+    if (force->inform == 2) {
+        force->inform = 3;
+    } else if (force->inform == 6) {
+        force->inform = 7;
+    }
+}
+
+void mBGMForce_room_nonstop_cleanup(BgmForce* force) {
+    if (force->roomNonstop == 2) {
+        force->roomNonstop = 3;
+    }
+}
+
+void mBGMForce_cleanup(BgmForce* force) {
+    mBGMForce_inform_cleanup(force);
+    mBGMForce_room_nonstop_cleanup(force);
+}
+
+void mBGMForce_inform_start() {
+    M_bgm.force.inform = 1;
+}
+
+void mBGMForce_inform_end() {
+    M_bgm.force.inform = 5;
+}
+
+void _mBGMForce_room_nonstop_start() {
+    M_bgm.force.roomNonstop = 1;
+}
+
+void mBGMForce_room_nonstop_start() {
+    _mBGMForce_room_nonstop_start();
+}
+
+void mBGM_main_control(Bgm* bgm) {
+    BgmPSComp* psComp = &bgm->psComp;
+
+    mBGMPsComp_main_req_md(psComp);
+    mBGMPsComp_main_req_stop(psComp);
+    mBGMPsComp_main_remove(psComp);
+    mBGMPsComp_main_req_start(psComp);
+    mBGMPsComp_main_req_pause(psComp);
+    mBGMPsComp_main_req_volume(psComp);
+    mBGMPsComp_main_inform_sound(psComp);
+    mBGMPsComp_main_md_move(psComp);
+    mBGMPsComp_main_counter_dec(psComp);
+    mBGMPsComp_main_fo_check(psComp);
+    mBGMPsComp_main_lost(psComp);
+}
+
+void mBGM_weather_set() {
+    s16 weather = common_data.weather;
+
+    if (weather >= mEnv_WEATHER_LEAVES) {
+        weather = mEnv_WEATHER_SAKURA;
+    } else if (weather < 0) {
+        weather = mEnv_WEATHER_CLEAR;
+    }
+
+    sAdo_Tenki(weather);
+}
+
+void mBGM_main(Game* game) {
+    Game_Play* play = (Game_Play*)game;
+
+    mBGMClock_move(&M_bgm.clock, play);
+    mBGMDemo_move(&M_bgm.demo, play);
+    mBGMRoom_move(&M_bgm.room, play);
+    mBGMFieldSuddenEv_move(&M_bgm.fieldSuddenEvent, play);
+    mBGMFieldSchedEv_move(&M_bgm.fieldScheduleEvent, play);
+    mBGMFieldNorm_move(&M_bgm.fieldNorm, play);
+    mBGMTime_move(&M_bgm.time, play);
+    mBGM_main_control(&M_bgm);
+    mBGMForce_move(&M_bgm.force);
+    mBGM_weather_set();
+}
+
+void mBGM_ct() {
+    mBGMClock_ct(&M_bgm.clock);
+    mBGMDemo_ct(&M_bgm.demo);
+    mBGMRoom_ct(&M_bgm.room);
+    mBGMTime_ct(&M_bgm.time);
+    mBGMFieldSuddenEv_ct(&M_bgm.fieldSuddenEvent);
+    mBGMFieldSchedEv_ct(&M_bgm.fieldScheduleEvent);
+    mBGMFieldNorm_ct(&M_bgm.fieldNorm);
+    mBGMPsComp_ct(&M_bgm.psComp);
+    mBGMForce_ct(&M_bgm.force);
+}
+
+void mBGM_init() {
+    mBGMPsComp_delete_ps_wipe();
+
+    if (mFI_CheckFieldData()) {
+        u16 fieldId = mFI_GetFieldId();
+        u16 fieldType = FI_GET_TYPE(fieldId);
+        BgmForce* force = &M_bgm.force;
+
+        if (fieldType == 0) {
+            if (mEv_CheckTitleDemo() > 0) {
+                mBGMPsComp_make_ps_demo(70, 0x168);
+            } else {
+                if ((force->inform != 3 && force->inform != 7) || force->flag) {
+                    mBGMFieldNorm_make_req();
+                }
+
+                if (force->inform == 3 && force->flag) {
+                    mBGMPsComp_make_ps_quiet(0x168);
+                }
+            }
+        } else if (fieldType == 0x3000 || fieldType == 0x4000 || fieldType == 0x6000) {
+            if (force->roomNonstop != 3) {
+                mBGMRoom_shop_close_time_set(&M_bgm.room);
+                mBGMRoom_scene_bgm_make_req();
+            }
+        } else {
+            mBGMDemo_scene_bgm_make_req();
+        }
+    }
+}
+
+void mBGM_cleanup() {
+    BgmForce* force = &M_bgm.force;
+
+    mBGMForce_cleanup(force);
+    if (mFI_CheckFieldData()) {
+        u16 fieldId = mFI_GetFieldId();
+        u16 fieldType = FI_GET_TYPE(fieldId);
+
+        if (fieldType == 0) {
+            if (mEv_CheckTitleDemo() > 0) {
+                mBGMPsComp_delete_ps_demo(70, 0x168);
+            } else {
+                if ((force->inform != 3 && force->inform != 7) || force->flag) {
+                    mBGMFieldNorm_delete_req();
+                }
+
+                if (force->inform == 7 && force->flag) {
+                    mBGMPsComp_delete_ps_quiet();
+                }
+            }
+        } else if (fieldType == 0x3000 || fieldType == 0x4000 || fieldType == 0x6000) {
+            if (force->roomNonstop != 3) {
+                mBGMRoom_scene_bgm_delete_req();
+            }
+        } else {
+            mBGMDemo_scene_bgm_delete_req();
+        }
+    }
+}
+
+void mBGM_reset() {
+    Bgm* bgm = &M_bgm;
+    BgmPSComp* psComp = &bgm->psComp;
+    BgmPS* ps = psComp->ps;
+    s32 i;
+    s32 max = psComp->psNum;
+
+    for (i = 0; i < max; i++, ps++) {
+        ps->cfFlags |= 1;
+        ps->element.stopType0 = 0x168;
+    }
+
+    psComp->talkState = 0;
+
+    if (psComp->pauseState != 0) {
+        sAdo_Pause(0);
+        psComp->pauseState = 0;
+    }
+
+    mBGMDemo_ct(&bgm->demo);
+    mBGMRoom_ct(&bgm->room);
+    mBGMTime_ct(&bgm->time);
+    mBGMFieldSuddenEv_ct(&bgm->fieldSuddenEvent);
+    mBGMFieldSchedEv_ct(&bgm->fieldScheduleEvent);
+    mBGMFieldNorm_ct(&bgm->fieldNorm);
+    mBGMForce_ct(&bgm->force);
+}
diff --git a/src/code/m_demo.c b/src/code/m_demo.c
index b6562e7..a317b24 100644
--- a/src/code/m_demo.c
+++ b/src/code/m_demo.c
@@ -7,7 +7,7 @@
 #include "libc/math.h"
 #include "m_field_info.h"
 #include "audio.h"
-#include "67E840.h"
+#include "m_bgm.h"
 
 f32 direct_vector[DEMO_DIRECT_MAX][2] = { { -1.0f, 0.0f },      { -M_SQRT2, M_SQRT2 }, { 0.0f, 1.0f },
                                           { M_SQRT2, M_SQRT2 }, { 1.0f, 0.0f },        { M_SQRT2, -M_SQRT2 },
diff --git a/src/code/m_field_info.c b/src/code/m_field_info.c
index 4932487..a005e5b 100644
--- a/src/code/m_field_info.c
+++ b/src/code/m_field_info.c
@@ -5,7 +5,7 @@
 
 #pragma GLOBAL_ASM("asm/jp/nonmatchings/code/m_field_info/mFI_ClearFieldData.s")
 
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/code/m_field_info/func_80087C40_jp.s")
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/code/m_field_info/mFI_CheckFieldData.s")
 
 #pragma GLOBAL_ASM("asm/jp/nonmatchings/code/m_field_info/mFI_GetBlockTopP.s")
 
@@ -259,7 +259,7 @@
 
 #pragma GLOBAL_ASM("asm/jp/nonmatchings/code/m_field_info/mFI_GetPlayerWade.s")
 
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/code/m_field_info/func_8008C130_jp.s")
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/code/m_field_info/mFI_GetNextBlockNum.s")
 
 #pragma GLOBAL_ASM("asm/jp/nonmatchings/code/m_field_info/mFI_GetDepositP.s")