Msgevent OK (#1637)

* Decompiled, some commands still unnamed

* Use full weekevent reg names

* Fix func_8094E69C

* Fix Player_GetMask

* Eventinf, mask worn, and item action argument formatting

* decimal rupees

* Times (day, hours, minutes) as decimal

* msgEventScriptPos

* Callbacks

* Name final commands

* Enum

* Arrays

* functions

* Small cleanups

* Clean up actors

* Remove event from some variable names to make them shorter

* Some more function renames

* newline

* Missed a few unks in commands

* Update functions.txt

* PlayerMask

* MSGMODE_PAUSED

* Script time macros

* EnSob1_GetWelcome default

* Whole bunch of renames

* Format

* Add CMD to commands

* Update code_functions

* structs for size

* z64scripts.h

* MsgEventCallback -> MsgScriptCallback

* format

* MsgEvent_RunScript stop

* Remove cmd handler comment

* cmd -> script in MsgEvent_RunScript

---------

Co-authored-by: Thar0 <17233964+Thar0@users.noreply.github.com>

8 files changed, 1236 insertions, 143 deletions

diff --git a/src/code/cutscene_camera.c b/src/code/cutscene_camera.c
index 6eb782787..20406e60a 100644
--- a/src/code/cutscene_camera.c
+++ b/src/code/cutscene_camera.c
@@ -1,4 +1,3 @@
-#include "prevent_bss_reordering.h"
 #include "global.h"
 #include "string.h"
 
diff --git a/src/code/z_bgcheck.c b/src/code/z_bgcheck.c
index 3bf910726..b27310b3f 100644
--- a/src/code/z_bgcheck.c
+++ b/src/code/z_bgcheck.c
@@ -1,5 +1,3 @@
-#include "prevent_bss_reordering.h"
-
 #include "z64bgcheck.h"
 #include "global.h"
 
diff --git a/src/code/z_collision_check.c b/src/code/z_collision_check.c
index 5b25e29b3..11c3865e1 100644
--- a/src/code/z_collision_check.c
+++ b/src/code/z_collision_check.c
@@ -1,4 +1,3 @@
-#include "prevent_bss_reordering.h"
 #include "z64collision_check.h"
 
 #include "z64actor.h"
diff --git a/src/code/z_kankyo.c b/src/code/z_kankyo.c
index ae2487ecc..bdfb36183 100644
--- a/src/code/z_kankyo.c
+++ b/src/code/z_kankyo.c
@@ -1674,27 +1674,27 @@ void func_800F88C4(u16 weekEventFlag) {
 }
 
 void func_800F8970(void) {
-    if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_27_40) && (SCHEDULE_TIME_NOW >= SCHEDULE_TIME(9, 31))) {
+    if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_27_40) && (SCRIPT_TIME_NOW >= SCRIPT_TIME(9, 31))) {
         SET_WEEKEVENTREG(WEEKEVENTREG_27_40);
         func_800F88C4(WEEKEVENTREG_DEPOSITED_LETTER_TO_KAFEI_SOUTH_UPPER_CLOCKTOWN);
     }
 
-    if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_27_80) && (SCHEDULE_TIME_NOW >= SCHEDULE_TIME(10, 3))) {
+    if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_27_80) && (SCRIPT_TIME_NOW >= SCRIPT_TIME(10, 3))) {
         SET_WEEKEVENTREG(WEEKEVENTREG_27_80);
         func_800F88C4(WEEKEVENTREG_DEPOSITED_LETTER_TO_KAFEI_NORTH_CLOCKTOWN);
     }
 
-    if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_28_01) && (SCHEDULE_TIME_NOW >= SCHEDULE_TIME(10, 35))) {
+    if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_28_01) && (SCRIPT_TIME_NOW >= SCRIPT_TIME(10, 35))) {
         SET_WEEKEVENTREG(WEEKEVENTREG_28_01);
         func_800F88C4(WEEKEVENTREG_DEPOSITED_LETTER_TO_KAFEI_EAST_UPPER_CLOCKTOWN);
     }
 
-    if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_28_02) && (SCHEDULE_TIME_NOW >= SCHEDULE_TIME(10, 53))) {
+    if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_28_02) && (SCRIPT_TIME_NOW >= SCRIPT_TIME(10, 53))) {
         SET_WEEKEVENTREG(WEEKEVENTREG_28_02);
         func_800F88C4(WEEKEVENTREG_DEPOSITED_LETTER_TO_KAFEI_EAST_LOWER_CLOCKTOWN);
     }
 
-    if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_28_04) && (SCHEDULE_TIME_NOW >= SCHEDULE_TIME(11, 25))) {
+    if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_28_04) && (SCRIPT_TIME_NOW >= SCRIPT_TIME(11, 25))) {
         SET_WEEKEVENTREG(WEEKEVENTREG_28_04);
         func_800F88C4(WEEKEVENTREG_DEPOSITED_LETTER_TO_KAFEI_SOUTH_LOWER_CLOCKTOWN);
     }
@@ -1729,7 +1729,7 @@ void Environment_UpdatePostmanEvents(PlayState* play) {
         CLEAR_WEEKEVENTREG(WEEKEVENTREG_28_04);
     }
 
-    if ((SCHEDULE_TIME_NOW < SCHEDULE_TIME(9, 0)) || (SCHEDULE_TIME_NOW > SCHEDULE_TIME(12, 0))) {
+    if ((SCRIPT_TIME_NOW < SCRIPT_TIME(9, 0)) || (SCRIPT_TIME_NOW > SCRIPT_TIME(12, 0))) {
         CLEAR_WEEKEVENTREG(WEEKEVENTREG_90_08);
     }
 
@@ -1738,14 +1738,14 @@ void Environment_UpdatePostmanEvents(PlayState* play) {
     if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_RECEIVED_ROOM_KEY) && !CHECK_WEEKEVENTREG(WEEKEVENTREG_55_02)) {
         if (((void)0, gSaveContext.save.day) >= 2) {
             SET_WEEKEVENTREG(WEEKEVENTREG_55_02);
-        } else if ((((void)0, gSaveContext.save.day) == 1) && (SCHEDULE_TIME_NOW >= SCHEDULE_TIME(16, 30))) {
+        } else if ((((void)0, gSaveContext.save.day) == 1) && (SCRIPT_TIME_NOW >= SCRIPT_TIME(16, 30))) {
             SET_WEEKEVENTREG(WEEKEVENTREG_55_02);
         }
     }
 
     if (!CHECK_WEEKEVENTREG(WEEKEVENTREG_90_01)) {
         temp_a2_2 = CURRENT_TIME - D_801F4E78;
-        if (CHECK_WEEKEVENTREG(WEEKEVENTREG_89_40) && ((u16)SCHEDULE_TIME_NOW >= (u16)SCHEDULE_TIME(5, 0))) {
+        if (CHECK_WEEKEVENTREG(WEEKEVENTREG_89_40) && ((u16)SCRIPT_TIME_NOW >= (u16)SCRIPT_TIME(5, 0))) {
             SET_WEEKEVENTREG(WEEKEVENTREG_90_01);
         } else if (CHECK_WEEKEVENTREG(WEEKEVENTREG_89_08) && (temp_a2_2 >= CLOCK_TIME(0, 23))) {
             SET_WEEKEVENTREG(WEEKEVENTREG_89_40);
diff --git a/src/code/z_lifemeter.c b/src/code/z_lifemeter.c
index ec2774b4b..54ad13dae 100644
--- a/src/code/z_lifemeter.c
+++ b/src/code/z_lifemeter.c
@@ -1,4 +1,3 @@
-#include "prevent_bss_reordering.h"
 #include "z64lifemeter.h"
 
 #include "global.h"
diff --git a/src/code/z_msgevent.c b/src/code/z_msgevent.c
index e3e45f900..d43aa3891 100644
--- a/src/code/z_msgevent.c
+++ b/src/code/z_msgevent.c
@@ -1,105 +1,1209 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010A760.s")
+/**
+ * Branch forward if the provided weekEventReg flag is set
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) flag
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckWeekEventReg(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckWeekEventReg* cmd = (MsgScriptCmdCheckWeekEventReg*)*script;
+    u16 flag = SCRIPT_PACK_16(cmd->flagByte, cmd->flagMask);
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010A7CC.s")
+    if (CHECK_WEEKEVENTREG(flag)) {
+        *script += skip;
+    }
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010A814.s")
+/**
+ * Branch forward if the player is currently in goron form
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_CheckGoron(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    Player* player = GET_PLAYER(play);
+    MsgScriptCmdCheckGoron* cmd = (MsgScriptCmdCheckGoron*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010A85C.s")
+    if (player->transformation == PLAYER_FORM_GORON) {
+        *script += skip;
+    }
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010A8A4.s")
+/**
+ * Branch forward if the player is currently in zora form
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_CheckZora(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    Player* player = GET_PLAYER(play);
+    MsgScriptCmdCheckZora* cmd = (MsgScriptCmdCheckZora*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010A8EC.s")
+    if (player->transformation == PLAYER_FORM_ZORA) {
+        *script += skip;
+    }
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010A990.s")
+/**
+ * Branch forward if the player is currently in deku form
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_CheckDeku(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    Player* player = GET_PLAYER(play);
+    MsgScriptCmdCheckDeku* cmd = (MsgScriptCmdCheckDeku*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AA54.s")
+    if (player->transformation == PLAYER_FORM_DEKU) {
+        *script += skip;
+    }
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AB30.s")
+/**
+ * Branch forward if the player is currently in human form
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_CheckHuman(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    Player* player = GET_PLAYER(play);
+    MsgScriptCmdCheckHuman* cmd = (MsgScriptCmdCheckHuman*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AB94.s")
+    if (player->transformation == PLAYER_FORM_HUMAN) {
+        *script += skip;
+    }
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AC00.s")
+/**
+ * Branch forward depending on the message choice index
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skipChoice1
+ *  3:(s16) skipChoice2
+ *  5:(s16) skipChoice3
+ * Command size: 7
+ */
+s32 MsgEvent_CheckTextChoice(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckTextChoice* cmd = (MsgScriptCmdCheckTextChoice*)*script;
+    s16 skip = 0;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AD24.s")
+    switch (play->msgCtx.choiceIndex) {
+        case 0:
+            skip = SCRIPT_PACK_16(cmd->offset0H, cmd->offset0L);
+            break;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010ADD4.s")
+        case 1:
+            skip = SCRIPT_PACK_16(cmd->offset1H, cmd->offset1L);
+            break;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AE48.s")
+        case 2:
+            skip = SCRIPT_PACK_16(cmd->offset2H, cmd->offset2L);
+            break;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AECC.s")
+        default:
+            break;
+    }
+    *script += skip;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AF20.s")
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AF6C.s")
+/**
+ * Branch forward if the actor has a parent, else get item
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) getItemId
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_OfferItem(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdOfferItem* cmd = (MsgScriptCmdOfferItem*)*script;
+    s32 getItemId = SCRIPT_PACK_16(cmd->itemIdH, cmd->itemIdL);
+    f32 xzRange = actor->xzDistToPlayer + 1.0f;
+    f32 yRange = fabsf(actor->playerHeightRel) + 1.0f;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AF94.s")
+    if (Actor_HasParent(actor, play)) {
+        *script += skip;
+    } else {
+        Actor_OfferGetItem(actor, play, getItemId, xzRange, yRange);
+        return true;
+    }
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010AFE0.s")
+/**
+ * Branch forward if there is a talk request, else autotalk
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_Autotalk(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdAutotalk* cmd = (MsgScriptCmdAutotalk*)*script;
+    f32 xzRange = actor->xzDistToPlayer + 1.0f;
+    f32 yRange = fabsf(actor->playerHeightRel) + 1.0f;
+    f32 xzDist;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B010.s")
+    if (Actor_TalkOfferAccepted(actor, &play->state)) {
+        *script += skip;
+    } else {
+        actor->flags |= ACTOR_FLAG_10000;
+        xzDist = actor->xzDistToPlayer;
+        actor->xzDistToPlayer = 0.0f;
+        Actor_OfferTalkExchange(actor, play, xzRange, yRange, PLAYER_IA_NONE);
+        actor->xzDistToPlayer = xzDist;
+        return true;
+    }
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B06C.s")
+/**
+ * Branch forward if the player currently has more rupees
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) rupees
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckRupees(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckRupees* cmd = (MsgScriptCmdCheckRupees*)*script;
+    s16 rupees = SCRIPT_PACK_16(cmd->rupeesH, cmd->rupeesL);
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B0B4.s")
+    if (gSaveContext.save.saveInfo.playerData.rupees >= rupees) {
+        *script += skip;
+    }
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B0DC.s")
+/**
+ * Branch forward if the callback is null or returns non-zero
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_CheckCallback(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckCallback* cmd = (MsgScriptCmdCheckCallback*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B108.s")
+    if ((callback == NULL) || (callback(actor, play) != 0)) {
+        *script += skip;
+    } else {
+        return true;
+    }
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B140.s")
+/**
+ * Branch forward based on time of day
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skipDay1
+ *  3:(s16) skipNight1
+ *  5:(s16) skipDay2
+ *  7:(s16) skipNight2
+ *  9:(s16) skipDay3
+ *  11:(s16) skipNight3
+ * Command size: 13
+ */
+s32 MsgEvent_CheckDay(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckDay* cmd = (MsgScriptCmdCheckDay*)*script;
+    s16 skip = 0;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B180.s")
+    switch (gSaveContext.save.day) {
+        case 1:
+            if (!gSaveContext.save.isNight) {
+                skip = SCRIPT_PACK_16(cmd->offsetDay1H, cmd->offsetDay1L);
+            } else {
+                skip = SCRIPT_PACK_16(cmd->offsetNight1H, cmd->offsetNight1L);
+            }
+            break;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B1BC.s")
+        case 2:
+            if (!gSaveContext.save.isNight) {
+                skip = SCRIPT_PACK_16(cmd->offsetDay2H, cmd->offsetDay2L);
+            } else {
+                skip = SCRIPT_PACK_16(cmd->offsetNight2H, cmd->offsetNight2L);
+            }
+            break;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B22C.s")
+        case 3:
+            if (!gSaveContext.save.isNight) {
+                skip = SCRIPT_PACK_16(cmd->offsetDay3H, cmd->offsetDay3L);
+            } else {
+                skip = SCRIPT_PACK_16(cmd->offsetNight3H, cmd->offsetNight3L);
+            }
+            break;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B284.s")
+        default:
+            break;
+    }
+    *script += skip;
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B2C0.s")
+/**
+ * Wait on choice text, skip forward when text closes.
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_AwaitTextJump(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdAwaitTextJump* cmd = (MsgScriptCmdAwaitTextJump*)*script;
+    s16 skip;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B300.s")
+    switch (Message_GetState(&play->msgCtx)) {
+        case TEXT_STATE_CHOICE:
+        case TEXT_STATE_EVENT:
+            if (!Message_ShouldAdvance(play)) {
+                return true;
+            }
+        case TEXT_STATE_CLOSING:
+            skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+            break;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B434.s")
+        default:
+            return true;
+    }
+    *script += skip;
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B4A4.s")
+/**
+ * Waits for text to advance
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_AwaitText(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    switch (Message_GetState(&play->msgCtx)) {
+        case TEXT_STATE_CHOICE:
+        case TEXT_STATE_EVENT:
+            if (!Message_ShouldAdvance(play)) {
+                return true;
+            }
+            break;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B520.s")
+        case TEXT_STATE_CLOSING:
+            break;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B664.s")
+        default:
+            return true;
+    }
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B7A8.s")
+/**
+ * Waits for text to end
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_AwaitTextEnd(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    s32 state = Message_GetState(&play->msgCtx);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B828.s")
+    *endScript = false;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B878.s")
+    switch (state) {
+        case TEXT_STATE_CHOICE:
+        case TEXT_STATE_EVENT:
+            if (!Message_ShouldAdvance(play)) {
+                break;
+            }
+        case TEXT_STATE_CLOSING:
+            *endScript = true;
+            break;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010B8E4.s")
+        default:
+            return true;
+    }
+    return true;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BB0C.s")
+/**
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) textId
+ * Command size: 3
+ */
+s32 MsgEvent_BeginText(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdBeginText* cmd = (MsgScriptCmdBeginText*)*script;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BB6C.s")
+    Message_StartTextbox(play, SCRIPT_PACK_16(cmd->textIdH, cmd->textIdL), NULL);
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BBCC.s")
+/**
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) textId
+ * Command size: 3
+ */
+s32 MsgEvent_ContinueText(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdContinueText* cmd = (MsgScriptCmdContinueText*)*script;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BC28.s")
+    Message_ContinueTextbox(play, SCRIPT_PACK_16(cmd->textIdH, cmd->textIdL));
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BC7C.s")
+/**
+ * Script Terminator
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_Done(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    *endScript = true;
+    return true;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BD48.s")
+/**
+ * Sets weekEventReg flags
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) flag
+ * Command size: 3
+ */
+s32 MsgEvent_SetWeekEventReg(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdSetWeekEventReg* cmd = (MsgScriptCmdSetWeekEventReg*)*script;
+    u16 flag = SCRIPT_PACK_16(cmd->flagByte, cmd->flagMask);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BD90.s")
+    SET_WEEKEVENTREG(flag);
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BDDC.s")
+/**
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_CloseText(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    Message_CloseTextbox(play);
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BE78.s")
+/**
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  0:(u16) flag
+ * Command size: 3
+ */
+s32 MsgEvent_SetCollectible(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdSetCollectible* cmd = (MsgScriptCmdSetCollectible*)*script;
+    s32 flag = SCRIPT_PACK_16(cmd->flagH, cmd->flagL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BEBC.s")
+    if (!Flags_GetCollectible(play, flag)) {
+        Flags_SetCollectible(play, flag);
+    }
+    actor->parent = NULL;
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BEF0.s")
+/**
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  0:(s16) rupees
+ * Command size: 3
+ */
+s32 MsgEvent_ChangeRupees(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdChangeRupees* cmd = (MsgScriptCmdChangeRupees*)*script;
+    s16 rupees = SCRIPT_PACK_16(cmd->rupeesH, cmd->rupeesL);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BF24.s")
+    Rupees_ChangeBy(rupees);
+    return false;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_msgevent/func_8010BF58.s")
+/**
+ * Pause the message system
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_Pause(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    play->msgCtx.msgMode = MSGMODE_PAUSED;
+    return false;
+}
+
+/**
+ * Unsets ACTOR_FLAG_10000 for the actor executing the cmd
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_UnsetAutotalk(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    actor->flags &= ~ACTOR_FLAG_10000;
+    return false;
+}
+
+/**
+ * Sets player focus & talk actor to the child of the actor executing the cmd
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_FocusToChild(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    if (actor->child != NULL) {
+        Actor_ChangeFocus(actor, play, actor->child);
+    }
+    return false;
+}
+
+/**
+ * Sets player focus & talk actor to the actor executing the cmd
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_FocusToSelf(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    if (actor->child != NULL) {
+        Actor_ChangeFocus(actor->child, play, actor);
+    }
+    return false;
+}
+
+/**
+ * Unconditional branch by `skip`
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_Jump(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdJump* cmd = (MsgScriptCmdJump*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    *script += skip;
+    return false;
+}
+
+/**
+ * Branch forwards if the specified quest item is obtained
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) questItem
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckQuestItem(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckQuestItem* cmd = (MsgScriptCmdCheckQuestItem*)*script;
+    u16 questItem = SCRIPT_PACK_16(cmd->questItemH, cmd->questItemL);
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    if (CHECK_QUEST_ITEM(questItem)) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Branch forwards if event_inf flag is set
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) event_inf flag
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckEventInf(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckEventInf* cmd = (MsgScriptCmdCheckEventInf*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    if (gSaveContext.eventInf[cmd->flagByte] & cmd->flagMask) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Sets event_inf flag
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) event_inf flag
+ * Command size: 3
+ */
+s32 MsgEvent_SetEventInf(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdSetEventInf* cmd = (MsgScriptCmdSetEventInf*)*script;
+
+    gSaveContext.eventInf[cmd->flagByte] |= cmd->flagMask;
+    return false;
+}
+
+/**
+ * Unsets event_inf flag
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) event_inf flag
+ * Command size: 3
+ */
+s32 MsgEvent_UnsetEventInf(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdUnsetEventInf* cmd = (MsgScriptCmdUnsetEventInf*)*script;
+
+    gSaveContext.eventInf[cmd->flagByte] &= cmd->flagMask ^ 0xFF;
+    return false;
+}
+
+/**
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) input player item-action
+ *  3:(s16) skip if player item-action matches input player item-action
+ *  5:(s16) skip if player item-action does not match input player item-action
+ *  7:(s16) skip if player item-action is negative
+ * Command size: 9
+ */
+s32 MsgEvent_CheckItemAction(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckItemAction* cmd = (MsgScriptCmdCheckItemAction*)*script;
+    PlayerItemAction checkItemAction = SCRIPT_PACK_16(cmd->itemActionH, cmd->itemActionL);
+    s16 skip;
+    PlayerItemAction curItemAction;
+
+    switch (Message_GetState(&play->msgCtx)) {
+        case TEXT_STATE_CHOICE:
+        case TEXT_STATE_EVENT:
+            if (!Message_ShouldAdvance(play)) {
+                return true;
+            }
+        case TEXT_STATE_PAUSE_MENU:
+            curItemAction = func_80123810(play);
+
+            if (curItemAction == PLAYER_IA_NONE) {
+                return true;
+            } else if (curItemAction < 0) {
+                skip = SCRIPT_PACK_16(cmd->offsetContinueH, cmd->offsetContinueL);
+            } else if (curItemAction == checkItemAction) {
+                skip = SCRIPT_PACK_16(cmd->offsetEqualH, cmd->offsetEqualL);
+            } else {
+                skip = SCRIPT_PACK_16(cmd->offsetDefaultH, cmd->offsetDefaultL);
+            }
+            break;
+
+        default:
+            return true;
+    }
+    *script += skip;
+    return false;
+}
+
+/**
+ * Branches forward if song is obtained
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) song
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckHasSong(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckHasSong* cmd = (MsgScriptCmdCheckHasSong*)*script;
+    u16 song = SCRIPT_PACK_16(cmd->songH, cmd->songL);
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    if (CHECK_QUEST_ITEM(QUEST_SONG_SONATA + song)) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Branches forward if the player's current mask matches
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) mask
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckWornMask(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckWornMask* cmd = (MsgScriptCmdCheckWornMask*)*script;
+    s32 mask = SCRIPT_PACK_16(cmd->maskH, cmd->maskL);
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    if (Player_GetMask(play) == mask) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Branches forward if the current time is greater than the provided time
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u8)  hour
+ *  1:(u8)  min
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckAfterTime(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckAfterTime* cmd = (MsgScriptCmdCheckAfterTime*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+    f32 f;
+    u16 time;
+    u16 now;
+
+    SCRIPT_CALC_TIME(cmd->hr, cmd->min, time, f);
+    now = SCRIPT_TIME_NOW;
+
+    if (time < now) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Branches forward if the current time is less or equal to the provided time
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u8)  hour
+ *  1:(u8)  min
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckBeforeTime(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckBeforeTime* cmd = (MsgScriptCmdCheckBeforeTime*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+    f32 f;
+    u16 time;
+    u16 now;
+
+    SCRIPT_CALC_TIME(cmd->hr, cmd->min, time, f);
+    now = SCRIPT_TIME_NOW;
+
+    if (time >= now) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Branches forward if switch flag is set
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) flag
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckSwitchFlag(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckSwitchFlag* cmd = (MsgScriptCmdCheckSwitchFlag*)*script;
+    s16 flag = SCRIPT_PACK_16(cmd->flagH, cmd->flagL);
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    if (Flags_GetSwitch(play, flag)) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Sets switch flag
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) flag
+ * Command size: 3
+ */
+s32 MsgEvent_SetSwitchFlag(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdSetSwitchFlag* cmd = (MsgScriptCmdSetSwitchFlag*)*script;
+    s16 flag = SCRIPT_PACK_16(cmd->flagH, cmd->flagL);
+
+    Flags_SetSwitch(play, flag);
+    return false;
+}
+
+/**
+ * Branches forward if item is in inventory
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) item
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckItem(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckItem* cmd = (MsgScriptCmdCheckItem*)*script;
+    u16 item = SCRIPT_PACK_16(cmd->itemH, cmd->itemL);
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    if (INV_CONTENT(item) == item) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Branches forward if current time is within the specified interval
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) startTime
+ *  3:(u16) endTime
+ *  5:(s16) skip
+ * Command size: 7
+ */
+s32 MsgEvent_CheckBetweenTime(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckBetweenTime* cmd = (MsgScriptCmdCheckBetweenTime*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+    f32 f;
+    u16 startTime;
+    u16 endTime;
+    u16 now;
+
+    SCRIPT_CALC_TIME(cmd->startHr, cmd->startMin, startTime, f);
+    SCRIPT_CALC_TIME(cmd->endHr, cmd->endMin, endTime, f);
+    endTime--;
+    now = SCRIPT_TIME_NOW;
+
+    if ((startTime >= now) || (now >= endTime)) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Branches forward if the current day matches
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) day
+ *  3:(s16) skip
+ * Command size: 5
+ */
+s32 MsgEvent_CheckOnDay(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckOnDay* cmd = (MsgScriptCmdCheckOnDay*)*script;
+    s16 day = SCRIPT_PACK_16(cmd->dayH, cmd->dayL);
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    if (gSaveContext.save.day == day) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Branches forward if callback exists and returns non-zero
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_CheckCallbackContinue(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback,
+                                   s32* endScript) {
+    MsgScriptCmdCheckCallbackContinue* cmd = (MsgScriptCmdCheckCallbackContinue*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    if ((callback != NULL) && (callback(actor, play) != 0)) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Skip forward if a powder keg is in inventory or if a powder keg actor exists
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_CheckHasPowderKeg(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdCheckHasPowderKeg* cmd = (MsgScriptCmdCheckHasPowderKeg*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    if ((AMMO(ITEM_POWDER_KEG) != 0) || (play->actorCtx.flags & ACTORCTX_FLAG_0)) {
+        *script += skip;
+    }
+    return false;
+}
+
+/**
+ * Deletes the specified item
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) item
+ * Command size: 3
+ */
+s32 MsgEvent_DeleteItem(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdDeleteItem* cmd = (MsgScriptCmdDeleteItem*)*script;
+    s16 item = SCRIPT_PACK_16(cmd->itemH, cmd->itemL);
+
+    Inventory_DeleteItem(item, SLOT(item));
+    return false;
+}
+
+/**
+ * Runs the callback and selects a skip based on the result, default skip is the first one
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ *  3:(s16) skip
+ *  5:(s16) skip
+ * Command size: 7
+ */
+s32 MsgEvent_CheckCallbackMulti(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback,
+                                s32* endScript) {
+    MsgScriptCmdCheckCallbackMulti* cmd = (MsgScriptCmdCheckCallbackMulti*)*script;
+    s32 ret = 1;
+    s16 skip;
+
+    if (callback != NULL) {
+        ret = callback(actor, play);
+    }
+    switch (ret) {
+        case 3:
+            skip = SCRIPT_PACK_16(cmd->offset3H, cmd->offset3L);
+            break;
+
+        case 2:
+            skip = SCRIPT_PACK_16(cmd->offset2H, cmd->offset2L);
+            break;
+
+        case 1:
+            skip = SCRIPT_PACK_16(cmd->offset1H, cmd->offset1L);
+            break;
+
+        default:
+            return true;
+    }
+    *script += skip;
+    return false;
+}
+
+/**
+ * Close the current textbox and set the player actor text id
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) textId
+ * Command size: 3
+ */
+s32 MsgEvent_PlayerTalk(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    Player* player = GET_PLAYER(play);
+    MsgScriptCmdPlayerTalk* cmd = (MsgScriptCmdPlayerTalk*)*script;
+    u16 textId = SCRIPT_PACK_16(cmd->textIdH, cmd->textIdL);
+
+    player->actor.textId = textId;
+    Message_CloseTextbox(play);
+    return false;
+}
+
+/**
+ * Queue a bomber's notebook event
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(u16) event
+ * Command size: 3
+ */
+s32 MsgEvent_NotebookEvent(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdBombersNotebook* cmd = (MsgScriptCmdBombersNotebook*)*script;
+    u16 event = SCRIPT_PACK_16(cmd->eventH, cmd->eventL);
+
+    Message_BombersNotebookQueueEvent(play, event);
+    return false;
+}
+
+/**
+ *
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_AwaitTextDone(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    switch (Message_GetState(&play->msgCtx)) {
+        case TEXT_STATE_CLOSING:
+            break;
+
+        case TEXT_STATE_CHOICE:
+        case TEXT_STATE_EVENT:
+            if (!Message_ShouldAdvance(play)) {
+                return true;
+            }
+
+        case TEXT_STATE_DONE:
+            if (!Message_ShouldAdvance(play)) {
+                return true;
+            }
+            break;
+
+        default:
+            return true;
+    }
+    return false;
+}
+
+/**
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ *  1:(s16) skip
+ * Command size: 3
+ */
+s32 MsgEvent_Jump3(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    MsgScriptCmdJump3* cmd = (MsgScriptCmdJump3*)*script;
+    s16 skip = SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
+
+    *script += skip;
+    *script += 3;
+    return true;
+}
+
+/**
+ * Plays Decide sfx
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_PlayDecide(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    Audio_PlaySfx_MessageDecide();
+    return false;
+}
+
+/**
+ * Plays Cancel sfx
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_PlayCancel(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    Audio_PlaySfx_MessageCancel();
+    return false;
+}
+
+/**
+ * Plays NA_SE_SY_ERROR sfx
+ *
+ * Command structure:
+ *  0:(u8)  cmd
+ * Command size: 1
+ */
+s32 MsgEvent_PlayError(Actor* actor, PlayState* play, u8** script, MsgScriptCallback callback, s32* endScript) {
+    Audio_PlaySfx(NA_SE_SY_ERROR);
+    return false;
+}
+
+typedef s32 (*MsgScriptCmdHandler)(struct Actor*, struct PlayState*, u8**, MsgScriptCallback, s32*);
+
+MsgScriptCmdHandler sMsgScriptCmdHandlers[] = {
+    MsgEvent_CheckWeekEventReg,     // MSCRIPT_CMD_ID_CHECK_WEEK_EVENT_REG
+    MsgEvent_CheckGoron,            // MSCRIPT_CMD_ID_CHECK_GORON
+    MsgEvent_CheckZora,             // MSCRIPT_CMD_ID_CHECK_ZORA
+    MsgEvent_CheckDeku,             // MSCRIPT_CMD_ID_CHECK_DEKU
+    MsgEvent_CheckHuman,            // MSCRIPT_CMD_ID_CHECK_HUMAN
+    MsgEvent_CheckTextChoice,       // MSCRIPT_CMD_ID_CHECK_TEXT_CHOICE
+    MsgEvent_OfferItem,             // MSCRIPT_CMD_ID_OFFER_ITEM
+    MsgEvent_Autotalk,              // MSCRIPT_CMD_ID_AUTOTALK
+    MsgEvent_CheckRupees,           // MSCRIPT_CMD_ID_CHECK_RUPEES
+    MsgEvent_CheckCallback,         // MSCRIPT_CMD_ID_CHECK_CALLBACK
+    MsgEvent_CheckDay,              // MSCRIPT_CMD_ID_CHECK_DAY
+    MsgEvent_AwaitTextJump,         // MSCRIPT_CMD_ID_AWAIT_TEXT_JUMP
+    MsgEvent_AwaitText,             // MSCRIPT_CMD_ID_AWAIT_TEXT
+    MsgEvent_AwaitTextEnd,          // MSCRIPT_CMD_ID_AWAIT_TEXT_END
+    MsgEvent_BeginText,             // MSCRIPT_CMD_ID_BEGIN_TEXT
+    MsgEvent_ContinueText,          // MSCRIPT_CMD_ID_CONTINUE_TEXT
+    MsgEvent_Done,                  // MSCRIPT_CMD_ID_DONE
+    MsgEvent_SetWeekEventReg,       // MSCRIPT_CMD_ID_SET_WEEK_EVENT_REG
+    MsgEvent_CloseText,             // MSCRIPT_CMD_ID_CLOSE_TEXT
+    MsgEvent_SetCollectible,        // MSCRIPT_CMD_ID_SET_COLLECTIBLE
+    MsgEvent_ChangeRupees,          // MSCRIPT_CMD_ID_CHANGE_RUPEES
+    MsgEvent_Pause,                 // MSCRIPT_CMD_ID_PAUSE
+    MsgEvent_UnsetAutotalk,         // MSCRIPT_CMD_ID_UNSET_AUTOTALK
+    MsgEvent_FocusToChild,          // MSCRIPT_CMD_ID_FOCUS_TO_CHILD
+    MsgEvent_FocusToSelf,           // MSCRIPT_CMD_ID_FOCUS_TO_SELF
+    MsgEvent_Jump,                  // MSCRIPT_CMD_ID_JUMP
+    MsgEvent_CheckQuestItem,        // MSCRIPT_CMD_ID_CHECK_QUEST_ITEM
+    MsgEvent_CheckEventInf,         // MSCRIPT_CMD_ID_CHECK_EVENT_INF
+    MsgEvent_SetEventInf,           // MSCRIPT_CMD_ID_SET_EVENT_INF
+    MsgEvent_UnsetEventInf,         // MSCRIPT_CMD_ID_UNSET_EVENT_INF
+    MsgEvent_CheckItemAction,       // MSCRIPT_CMD_ID_CHECK_ITEM_ACTION
+    MsgEvent_CheckHasSong,          // MSCRIPT_CMD_ID_CHECK_HAS_SONG
+    MsgEvent_CheckWornMask,         // MSCRIPT_CMD_ID_CHECK_WORN_MASK
+    MsgEvent_CheckAfterTime,        // MSCRIPT_CMD_ID_CHECK_AFTER_TIME
+    MsgEvent_CheckBeforeTime,       // MSCRIPT_CMD_ID_CHECK_BEFORE_TIME
+    MsgEvent_CheckSwitchFlag,       // MSCRIPT_CMD_ID_CHECK_SWITCH_FLAG
+    MsgEvent_SetSwitchFlag,         // MSCRIPT_CMD_ID_SET_SWITCH_FLAG
+    MsgEvent_CheckItem,             // MSCRIPT_CMD_ID_CHECK_ITEM
+    MsgEvent_CheckBetweenTime,      // MSCRIPT_CMD_ID_CHECK_BETWEEN_TIME
+    MsgEvent_CheckOnDay,            // MSCRIPT_CMD_ID_CHECK_ON_DAY
+    MsgEvent_CheckCallbackContinue, // MSCRIPT_CMD_ID_CHECK_CALLBACK_CONTINUE
+    MsgEvent_CheckHasPowderKeg,     // MSCRIPT_CMD_ID_CHECK_HAS_POWDER_KEG
+    MsgEvent_DeleteItem,            // MSCRIPT_CMD_ID_DELETE_ITEM
+    MsgEvent_CheckCallbackMulti,    // MSCRIPT_CMD_ID_CHECK_CALLBACK_MULTI
+    MsgEvent_PlayerTalk,            // MSCRIPT_CMD_ID_PLAYER_TALK
+    MsgEvent_NotebookEvent,         // MSCRIPT_CMD_ID_NOTEBOOK_EVENT
+    MsgEvent_AwaitTextDone,         // MSCRIPT_CMD_ID_AWAIT_TEXT_DONE
+    MsgEvent_Jump3,                 // MSCRIPT_CMD_ID_JUMP_3
+    MsgEvent_PlayDecide,            // MSCRIPT_CMD_ID_PLAY_DECIDE
+    MsgEvent_PlayCancel,            // MSCRIPT_CMD_ID_PLAY_CANCEL
+    MsgEvent_PlayError,             // MSCRIPT_CMD_ID_PLAY_ERROR
+};
+
+u8 sMsgScriptCmdSizes[] = {
+    sizeof(MsgScriptCmdCheckWeekEventReg),     // MSCRIPT_CMD_ID_CHECK_WEEK_EVENT_REG
+    sizeof(MsgScriptCmdCheckGoron),            // MSCRIPT_CMD_ID_CHECK_GORON
+    sizeof(MsgScriptCmdCheckZora),             // MSCRIPT_CMD_ID_CHECK_ZORA
+    sizeof(MsgScriptCmdCheckDeku),             // MSCRIPT_CMD_ID_CHECK_DEKU
+    sizeof(MsgScriptCmdCheckHuman),            // MSCRIPT_CMD_ID_CHECK_HUMAN
+    sizeof(MsgScriptCmdCheckTextChoice),       // MSCRIPT_CMD_ID_CHECK_TEXT_CHOICE
+    sizeof(MsgScriptCmdOfferItem),             // MSCRIPT_CMD_ID_OFFER_ITEM
+    sizeof(MsgScriptCmdAutotalk),              // MSCRIPT_CMD_ID_AUTOTALK
+    sizeof(MsgScriptCmdCheckRupees),           // MSCRIPT_CMD_ID_CHECK_RUPEES
+    sizeof(MsgScriptCmdCheckCallback),         // MSCRIPT_CMD_ID_CHECK_CALLBACK
+    sizeof(MsgScriptCmdCheckDay),              // MSCRIPT_CMD_ID_CHECK_DAY,
+    sizeof(MsgScriptCmdAwaitTextJump),         // MSCRIPT_CMD_ID_AWAIT_TEXT_JUMP
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_AWAIT_TEXT
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_AWAIT_TEXT_END
+    sizeof(MsgScriptCmdBeginText),             // MSCRIPT_CMD_ID_BEGIN_TEXT
+    sizeof(MsgScriptCmdContinueText),          // MSCRIPT_CMD_ID_CONTINUE_TEXT
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_DONE
+    sizeof(MsgScriptCmdSetWeekEventReg),       // MSCRIPT_CMD_ID_SET_WEEK_EVENT_REG
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_CLOSE_TEXT
+    sizeof(MsgScriptCmdSetCollectible),        // MSCRIPT_CMD_ID_SET_COLLECTIBLE
+    sizeof(MsgScriptCmdChangeRupees),          // MSCRIPT_CMD_ID_CHANGE_RUPEES
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_PAUSE
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_UNSET_AUTOTALK
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_FOCUS_TO_CHILD
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_FOCUS_TO_SELF
+    sizeof(MsgScriptCmdJump),                  // MSCRIPT_CMD_ID_JUMP
+    sizeof(MsgScriptCmdCheckQuestItem),        // MSCRIPT_CMD_ID_CHECK_QUEST_ITEM
+    sizeof(MsgScriptCmdCheckEventInf),         // MSCRIPT_CMD_ID_CHECK_EVENT_INF
+    sizeof(MsgScriptCmdSetEventInf),           // MSCRIPT_CMD_ID_SET_EVENT_INF
+    sizeof(MsgScriptCmdUnsetEventInf),         // MSCRIPT_CMD_ID_UNSET_EVENT_INF
+    sizeof(MsgScriptCmdCheckItemAction),       // MSCRIPT_CMD_ID_CHECK_ITEM_ACTION
+    sizeof(MsgScriptCmdCheckHasSong),          // MSCRIPT_CMD_ID_CHECK_HAS_SONG
+    sizeof(MsgScriptCmdCheckWornMask),         // MSCRIPT_CMD_ID_CHECK_WORN_MASK
+    sizeof(MsgScriptCmdCheckAfterTime),        // MSCRIPT_CMD_ID_CHECK_AFTER_TIME
+    sizeof(MsgScriptCmdCheckBeforeTime),       // MSCRIPT_CMD_ID_CHECK_BEFORE_TIME
+    sizeof(MsgScriptCmdCheckSwitchFlag),       // MSCRIPT_CMD_ID_CHECK_SWITCH_FLAG
+    sizeof(MsgScriptCmdSetSwitchFlag),         // MSCRIPT_CMD_ID_SET_SWITCH_FLAG
+    sizeof(MsgScriptCmdCheckItem),             // MSCRIPT_CMD_ID_CHECK_ITEM
+    sizeof(MsgScriptCmdCheckBetweenTime),      // MSCRIPT_CMD_ID_CHECK_BETWEEN_TIME
+    sizeof(MsgScriptCmdCheckOnDay),            // MSCRIPT_CMD_ID_CHECK_ON_DAY
+    sizeof(MsgScriptCmdCheckCallbackContinue), // MSCRIPT_CMD_ID_CHECK_CALLBACK_CONTINUE
+    sizeof(MsgScriptCmdCheckHasPowderKeg),     // MSCRIPT_CMD_ID_CHECK_HAS_POWDER_KEG
+    sizeof(MsgScriptCmdDeleteItem),            // MSCRIPT_CMD_ID_DELETE_ITEM
+    sizeof(MsgScriptCmdCheckCallbackMulti),    // MSCRIPT_CMD_ID_CHECK_CALLBACK_MULTI
+    sizeof(MsgScriptCmdPlayerTalk),            // MSCRIPT_CMD_ID_PLAYER_TALK
+    sizeof(MsgScriptCmdBombersNotebook),       // MSCRIPT_CMD_ID_NOTEBOOK_EVENT
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_AWAIT_TEXT_DONE
+    sizeof(MsgScriptCmdJump3),                 // MSCRIPT_CMD_ID_JUMP_3
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_PLAY_DECIDE
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_PLAY_CANCEL
+    sizeof(MsgScriptCmdBase),                  // MSCRIPT_CMD_ID_PLAY_ERROR
+};
+
+/**
+ * Runs a message event script
+ *
+ * @param actor         The actor associated with the cmd
+ * @param play          Play game state
+ * @param script        The script to run
+ * @param callback      Callback function used by various commands for different purposes
+ * @param[in,out] pos   Position to resume the cmd from, the point at which the cmd stops executing is also
+ *                      written out here
+ * @return s32  Whether the cmd has reached an endpoint
+ */
+s32 MsgEvent_RunScript(Actor* actor, PlayState* play, MsgScript* script, MsgScriptCallback callback, s32* pos) {
+    u8* start;
+    u8* cur;
+    s32 scriptDone = false;
+    s32 i;
+    s32 cmdLen;
+    u8 cmdId;
+    s32 stop;
+
+    start = script;
+    script += *pos;
+
+    if (sREG(95) != 0) {}
+
+    cmdLen = 0;
+    do {
+        // Skip data from previous command
+        script += cmdLen;
+
+        // Get command id
+        cmdId = *script;
+
+        // Get command length
+        if (cmdId < ARRAY_COUNTU(sMsgScriptCmdSizes)) {
+            cmdLen = sMsgScriptCmdSizes[cmdId];
+        } else {
+            cmdLen = -1;
+            //! @bug command handler still runs even if cmdId is invalid
+        }
+
+        // Debug loop?
+        if (sREG(95) != 0) {
+            for (i = 0; i < cmdLen; i++) {}
+        }
+
+        stop = sMsgScriptCmdHandlers[cmdId](actor, play, &script, callback, &scriptDone);
+    } while (!stop);
+
+    cur = script;
+    if (!scriptDone) {
+        *pos = cur - start;
+    } else {
+        *pos = 0;
+    }
+    return scriptDone;
+}
diff --git a/src/code/z_player_lib.c b/src/code/z_player_lib.c
index f08a1f4b5..d4ab77899 100644
--- a/src/code/z_player_lib.c
+++ b/src/code/z_player_lib.c
@@ -1383,7 +1383,7 @@ u8 Player_GetStrength(void) {
     return sPlayerStrengths[GET_PLAYER_FORM];
 }
 
-u8 Player_GetMask(PlayState* play) {
+PlayerMask Player_GetMask(PlayState* play) {
     Player* player = GET_PLAYER(play);
 
     return player->currentMask;
diff --git a/src/code/z_schedule.c b/src/code/z_schedule.c
index 716111ff1..243516c95 100644
--- a/src/code/z_schedule.c
+++ b/src/code/z_schedule.c
@@ -1,14 +1,8 @@
 #include "global.h"
 
-#define SCHEDULE_CALC_TIME(hour, minute, dest, temp) \
-    (temp) = (hour)*60.0f;                           \
-    (temp) += (minute);                              \
-    (dest) = (temp) * (0x10000 / 60 / 24.0f);        \
-    (dest) = SCHEDULE_CONVERT_TIME(dest)
-
-s32 Schedule_CheckFlagS(PlayState* play, u8** script, ScheduleOutput* output) {
-    ScheduleCmdCheckFlagS* cmd = (ScheduleCmdCheckFlagS*)*script;
-    u16 flag = PACK_WEEKEVENTREG_FLAG(cmd->flagByte, cmd->flagMask);
+s32 Schedule_CheckWeekEventRegS(PlayState* play, u8** script, ScheduleOutput* output) {
+    ScheduleCmdCheckWeekEventRegS* cmd = (ScheduleCmdCheckWeekEventRegS*)*script;
+    u16 flag = SCRIPT_PACK_16(cmd->flagByte, cmd->flagMask);
 
     if (CHECK_WEEKEVENTREG(flag)) {
         *script += cmd->offset;
@@ -17,12 +11,12 @@ s32 Schedule_CheckFlagS(PlayState* play, u8** script, ScheduleOutput* output) {
     return false;
 }
 
-s32 Schedule_CheckFlagL(PlayState* play, u8** script, ScheduleOutput* output) {
-    ScheduleCmdCheckFlagL* cmd = (ScheduleCmdCheckFlagL*)*script;
-    u16 flag = PACK_WEEKEVENTREG_FLAG(cmd->flagByte, cmd->flagMask);
+s32 Schedule_CheckWeekEventRegL(PlayState* play, u8** script, ScheduleOutput* output) {
+    ScheduleCmdCheckWeekEventRegL* cmd = (ScheduleCmdCheckWeekEventRegL*)*script;
+    u16 flag = SCRIPT_PACK_16(cmd->flagByte, cmd->flagMask);
 
     if (CHECK_WEEKEVENTREG(flag)) {
-        *script += (s16)((cmd->offsetH << 8) | cmd->offsetL);
+        *script += (s16)SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
     }
 
     return false;
@@ -36,12 +30,12 @@ s32 Schedule_CheckTimeRangeS(PlayState* play, u8** script, ScheduleOutput* outpu
     u16 end;
     u16 now;
 
-    SCHEDULE_CALC_TIME(cmd->startHr, cmd->startMin, start, f);
+    SCRIPT_CALC_TIME(cmd->startHr, cmd->startMin, start, f);
 
-    SCHEDULE_CALC_TIME(cmd->endHr, cmd->endMin, end, f);
+    SCRIPT_CALC_TIME(cmd->endHr, cmd->endMin, end, f);
     end--;
 
-    now = SCHEDULE_TIME_NOW;
+    now = SCRIPT_TIME_NOW;
 
     if ((start <= now) && (now <= end)) {
         inRange = true;
@@ -62,19 +56,19 @@ s32 Schedule_CheckTimeRangeL(PlayState* play, u8** script, ScheduleOutput* outpu
     u16 end;
     u16 now;
 
-    SCHEDULE_CALC_TIME(cmd->startHr, cmd->startMin, start, f);
+    SCRIPT_CALC_TIME(cmd->startHr, cmd->startMin, start, f);
 
-    SCHEDULE_CALC_TIME(cmd->endHr, cmd->endMin, end, f);
+    SCRIPT_CALC_TIME(cmd->endHr, cmd->endMin, end, f);
     end--;
 
-    now = SCHEDULE_TIME_NOW;
+    now = SCRIPT_TIME_NOW;
 
     if ((start <= now) && (now <= end)) {
         inRange = true;
     }
 
     if (inRange == true) {
-        *script += (s16)((cmd->offsetH << 8) | cmd->offsetL);
+        *script += (s16)SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
     }
 
     return false;
@@ -84,7 +78,7 @@ s32 Schedule_ReturnValueL(PlayState* play, u8** script, ScheduleOutput* output)
     ScheduleCmdReturnValueL* cmd = (ScheduleCmdReturnValueL*)*script;
 
     //! @bug result is a u8, value is truncated
-    output->result = (cmd->retH << 8) | cmd->retL;
+    output->result = SCRIPT_PACK_16(cmd->retH, cmd->retL);
     output->hasResult = true;
 
     return true;
@@ -130,7 +124,7 @@ s32 Schedule_ReturnValueS(PlayState* play, u8** script, ScheduleOutput* output)
 
 s32 Schedule_CheckNotInSceneS(PlayState* play, u8** script, ScheduleOutput* output) {
     ScheduleCmdCheckNotInSceneS* cmd = (ScheduleCmdCheckNotInSceneS*)*script;
-    s16 sceneId = (cmd->sceneIdH << 8) | cmd->sceneIdL;
+    s16 sceneId = SCRIPT_PACK_16(cmd->sceneIdH, cmd->sceneIdL);
 
     if (sceneId != play->sceneId) {
         *script += cmd->offset;
@@ -141,10 +135,10 @@ s32 Schedule_CheckNotInSceneS(PlayState* play, u8** script, ScheduleOutput* outp
 
 s32 Schedule_CheckNotInSceneL(PlayState* play, u8** script, ScheduleOutput* output) {
     ScheduleCmdCheckNotInSceneL* cmd = (ScheduleCmdCheckNotInSceneL*)*script;
-    s16 sceneId = (cmd->sceneIdH << 8) | cmd->sceneIdL;
+    s16 sceneId = SCRIPT_PACK_16(cmd->sceneIdH, cmd->sceneIdL);
 
     if (sceneId != play->sceneId) {
-        *script = *script + (s16)((cmd->offsetH << 8) | cmd->offsetL);
+        *script += (s16)SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
     }
 
     return false;
@@ -152,7 +146,7 @@ s32 Schedule_CheckNotInSceneL(PlayState* play, u8** script, ScheduleOutput* outp
 
 s32 Schedule_CheckNotInDayS(PlayState* play, u8** script, ScheduleOutput* output) {
     ScheduleCmdCheckNotInDayS* cmd = (ScheduleCmdCheckNotInDayS*)*script;
-    s16 day = (cmd->dayH << 8) | cmd->dayL;
+    s16 day = SCRIPT_PACK_16(cmd->dayH, cmd->dayL);
 
     if (day != (s16)gSaveContext.save.day) {
         *script += cmd->offset;
@@ -163,10 +157,10 @@ s32 Schedule_CheckNotInDayS(PlayState* play, u8** script, ScheduleOutput* output
 
 s32 Schedule_CheckNotInDayL(PlayState* play, u8** script, ScheduleOutput* output) {
     ScheduleCmdCheckNotInDayL* cmd = (ScheduleCmdCheckNotInDayL*)*script;
-    s16 day = (cmd->dayH << 8) | cmd->dayL;
+    s16 day = SCRIPT_PACK_16(cmd->dayH, cmd->dayL);
 
     if (day != (s16)gSaveContext.save.day) {
-        *script += (s16)((cmd->offsetH << 8) | cmd->offsetL);
+        *script += (s16)SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
     }
 
     return false;
@@ -178,9 +172,9 @@ s32 Schedule_ReturnTime(PlayState* play, u8** script, ScheduleOutput* output) {
     u16 time0;
     u16 time1;
 
-    SCHEDULE_CALC_TIME(cmd->time0Hr, cmd->time0Min, time0, f);
+    SCRIPT_CALC_TIME(cmd->time0Hr, cmd->time0Min, time0, f);
 
-    SCHEDULE_CALC_TIME(cmd->time1Hr, cmd->time1Min, time1, f);
+    SCRIPT_CALC_TIME(cmd->time1Hr, cmd->time1Min, time1, f);
     time1--;
 
     output->result = cmd->result;
@@ -197,9 +191,9 @@ s32 Schedule_CheckBeforeTimeS(PlayState* play, u8** script, ScheduleOutput* outp
     u16 testTime;
     u16 now;
 
-    SCHEDULE_CALC_TIME(cmd->timeHr, cmd->timeMin, testTime, f);
+    SCRIPT_CALC_TIME(cmd->timeHr, cmd->timeMin, testTime, f);
 
-    now = SCHEDULE_TIME_NOW;
+    now = SCRIPT_TIME_NOW;
 
     if (now < testTime) {
         *script += cmd->offset;
@@ -214,12 +208,12 @@ s32 Schedule_CheckBeforeTimeL(PlayState* play, u8** script, ScheduleOutput* outp
     u16 testTime;
     u16 now;
 
-    SCHEDULE_CALC_TIME(cmd->timeHr, cmd->timeMin, testTime, f);
+    SCRIPT_CALC_TIME(cmd->timeHr, cmd->timeMin, testTime, f);
 
-    now = SCHEDULE_TIME_NOW;
+    now = SCRIPT_TIME_NOW;
 
     if (now < testTime) {
-        *script += (s16)((cmd->offsetH << 8) | cmd->offsetL);
+        *script += (s16)SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
     }
 
     return false;
@@ -235,54 +229,54 @@ s32 Schedule_BranchS(PlayState* play, u8** script, ScheduleOutput* output) {
 s32 Schedule_BranchL(PlayState* play, u8** script, ScheduleOutput* output) {
     ScheduleCmdBranchL* cmd = (ScheduleCmdBranchL*)*script;
 
-    *script += (s16)((cmd->offsetH << 8) | cmd->offsetL);
+    *script += (s16)SCRIPT_PACK_16(cmd->offsetH, cmd->offsetL);
     return false;
 }
 
-typedef s32 (*ScheduleCmdFunc)(PlayState*, u8**, ScheduleOutput*);
-
-static ScheduleCmdFunc sScheduleCmdFuncs[] = {
-    Schedule_CheckFlagS,       // SCHEDULE_CMD_ID_CHECK_FLAG_S
-    Schedule_CheckFlagL,       // SCHEDULE_CMD_ID_CHECK_FLAG_L
-    Schedule_CheckTimeRangeS,  // SCHEDULE_CMD_ID_CHECK_TIME_RANGE_S
-    Schedule_CheckTimeRangeL,  // SCHEDULE_CMD_ID_CHECK_TIME_RANGE_L
-    Schedule_ReturnValueL,     // SCHEDULE_CMD_ID_RET_VAL_L
-    Schedule_ReturnNone,       // SCHEDULE_CMD_ID_RET_NONE
-    Schedule_ReturnEmpty,      // SCHEDULE_CMD_ID_RET_EMPTY
-    Schedule_Nop,              // SCHEDULE_CMD_ID_NOP
-    Schedule_CheckMiscS,       // SCHEDULE_CMD_ID_CHECK_MISC_S
-    Schedule_ReturnValueS,     // SCHEDULE_CMD_ID_RET_VAL_S
-    Schedule_CheckNotInSceneS, // SCHEDULE_CMD_ID_CHECK_NOT_IN_SCENE_S
-    Schedule_CheckNotInSceneL, // SCHEDULE_CMD_ID_CHECK_NOT_IN_SCENE_L
-    Schedule_CheckNotInDayS,   // SCHEDULE_CMD_ID_CHECK_NOT_IN_DAY_S
-    Schedule_CheckNotInDayL,   // SCHEDULE_CMD_ID_CHECK_NOT_IN_DAY_L
-    Schedule_ReturnTime,       // SCHEDULE_CMD_ID_RET_TIME
-    Schedule_CheckBeforeTimeS, // SCHEDULE_CMD_ID_CHECK_BEFORE_TIME_S
-    Schedule_CheckBeforeTimeL, // SCHEDULE_CMD_ID_CHECK_BEFORE_TIME_L
-    Schedule_BranchS,          // SCHEDULE_CMD_ID_BRANCH_S
-    Schedule_BranchL,          // SCHEDULE_CMD_ID_BRANCH_L
+typedef s32 (*ScheduleCmdHandler)(PlayState*, u8**, ScheduleOutput*);
+
+static ScheduleCmdHandler sScheduleCmdHandlers[] = {
+    Schedule_CheckWeekEventRegS, // SCHEDULE_CMD_ID_CHECK_WEEK_EVENT_REG_S
+    Schedule_CheckWeekEventRegL, // SCHEDULE_CMD_ID_CHECK_WEEK_EVENT_REG_L
+    Schedule_CheckTimeRangeS,    // SCHEDULE_CMD_ID_CHECK_TIME_RANGE_S
+    Schedule_CheckTimeRangeL,    // SCHEDULE_CMD_ID_CHECK_TIME_RANGE_L
+    Schedule_ReturnValueL,       // SCHEDULE_CMD_ID_RET_VAL_L
+    Schedule_ReturnNone,         // SCHEDULE_CMD_ID_RET_NONE
+    Schedule_ReturnEmpty,        // SCHEDULE_CMD_ID_RET_EMPTY
+    Schedule_Nop,                // SCHEDULE_CMD_ID_NOP
+    Schedule_CheckMiscS,         // SCHEDULE_CMD_ID_CHECK_MISC_S
+    Schedule_ReturnValueS,       // SCHEDULE_CMD_ID_RET_VAL_S
+    Schedule_CheckNotInSceneS,   // SCHEDULE_CMD_ID_CHECK_NOT_IN_SCENE_S
+    Schedule_CheckNotInSceneL,   // SCHEDULE_CMD_ID_CHECK_NOT_IN_SCENE_L
+    Schedule_CheckNotInDayS,     // SCHEDULE_CMD_ID_CHECK_NOT_IN_DAY_S
+    Schedule_CheckNotInDayL,     // SCHEDULE_CMD_ID_CHECK_NOT_IN_DAY_L
+    Schedule_ReturnTime,         // SCHEDULE_CMD_ID_RET_TIME
+    Schedule_CheckBeforeTimeS,   // SCHEDULE_CMD_ID_CHECK_BEFORE_TIME_S
+    Schedule_CheckBeforeTimeL,   // SCHEDULE_CMD_ID_CHECK_BEFORE_TIME_L
+    Schedule_BranchS,            // SCHEDULE_CMD_ID_BRANCH_S
+    Schedule_BranchL,            // SCHEDULE_CMD_ID_BRANCH_L
 };
 
 static u8 sScheduleCmdSizes[] = {
-    sizeof(ScheduleCmdCheckFlagS),       // SCHEDULE_CMD_ID_CHECK_FLAG_S
-    sizeof(ScheduleCmdCheckFlagL),       // SCHEDULE_CMD_ID_CHECK_FLAG_L
-    sizeof(ScheduleCmdCheckTimeRangeS),  // SCHEDULE_CMD_ID_CHECK_TIME_RANGE_S
-    sizeof(ScheduleCmdCheckTimeRangeL),  // SCHEDULE_CMD_ID_CHECK_TIME_RANGE_L
-    sizeof(ScheduleCmdReturnValueL),     // SCHEDULE_CMD_ID_RET_VAL_L
-    sizeof(ScheduleCmdBase),             // SCHEDULE_CMD_ID_RET_NONE
-    sizeof(ScheduleCmdBase),             // SCHEDULE_CMD_ID_RET_EMPTY
-    sizeof(ScheduleCmdNop),              // SCHEDULE_CMD_ID_NOP
-    sizeof(ScheduleCmdCheckMiscS),       // SCHEDULE_CMD_ID_CHECK_MISC_S
-    sizeof(ScheduleCmdReturnValueS),     // SCHEDULE_CMD_ID_RET_VAL_S
-    sizeof(ScheduleCmdCheckNotInSceneS), // SCHEDULE_CMD_ID_CHECK_NOT_IN_SCENE_S
-    sizeof(ScheduleCmdCheckNotInSceneL), // SCHEDULE_CMD_ID_CHECK_NOT_IN_SCENE_L
-    sizeof(ScheduleCmdCheckNotInDayS),   // SCHEDULE_CMD_ID_CHECK_NOT_IN_DAY_S
-    sizeof(ScheduleCmdCheckNotInDayL),   // SCHEDULE_CMD_ID_CHECK_NOT_IN_DAY_L
-    sizeof(ScheduleCmdReturnTime),       // SCHEDULE_CMD_ID_RET_TIME
-    sizeof(ScheduleCmdCheckBeforeTimeS), // SCHEDULE_CMD_ID_CHECK_BEFORE_TIME_S
-    sizeof(ScheduleCmdCheckBeforeTimeL), // SCHEDULE_CMD_ID_CHECK_BEFORE_TIME_L
-    sizeof(ScheduleCmdBranchS),          // SCHEDULE_CMD_ID_BRANCH_S
-    sizeof(ScheduleCmdBranchL),          // SCHEDULE_CMD_ID_BRANCH_L
+    sizeof(ScheduleCmdCheckWeekEventRegS), // SCHEDULE_CMD_ID_CHECK_WEEK_EVENT_REG_S
+    sizeof(ScheduleCmdCheckWeekEventRegL), // SCHEDULE_CMD_ID_CHECK_WEEK_EVENT_REG_L
+    sizeof(ScheduleCmdCheckTimeRangeS),    // SCHEDULE_CMD_ID_CHECK_TIME_RANGE_S
+    sizeof(ScheduleCmdCheckTimeRangeL),    // SCHEDULE_CMD_ID_CHECK_TIME_RANGE_L
+    sizeof(ScheduleCmdReturnValueL),       // SCHEDULE_CMD_ID_RET_VAL_L
+    sizeof(ScheduleCmdBase),               // SCHEDULE_CMD_ID_RET_NONE
+    sizeof(ScheduleCmdBase),               // SCHEDULE_CMD_ID_RET_EMPTY
+    sizeof(ScheduleCmdNop),                // SCHEDULE_CMD_ID_NOP
+    sizeof(ScheduleCmdCheckMiscS),         // SCHEDULE_CMD_ID_CHECK_MISC_S
+    sizeof(ScheduleCmdReturnValueS),       // SCHEDULE_CMD_ID_RET_VAL_S
+    sizeof(ScheduleCmdCheckNotInSceneS),   // SCHEDULE_CMD_ID_CHECK_NOT_IN_SCENE_S
+    sizeof(ScheduleCmdCheckNotInSceneL),   // SCHEDULE_CMD_ID_CHECK_NOT_IN_SCENE_L
+    sizeof(ScheduleCmdCheckNotInDayS),     // SCHEDULE_CMD_ID_CHECK_NOT_IN_DAY_S
+    sizeof(ScheduleCmdCheckNotInDayL),     // SCHEDULE_CMD_ID_CHECK_NOT_IN_DAY_L
+    sizeof(ScheduleCmdReturnTime),         // SCHEDULE_CMD_ID_RET_TIME
+    sizeof(ScheduleCmdCheckBeforeTimeS),   // SCHEDULE_CMD_ID_CHECK_BEFORE_TIME_S
+    sizeof(ScheduleCmdCheckBeforeTimeL),   // SCHEDULE_CMD_ID_CHECK_BEFORE_TIME_L
+    sizeof(ScheduleCmdBranchS),            // SCHEDULE_CMD_ID_BRANCH_S
+    sizeof(ScheduleCmdBranchL),            // SCHEDULE_CMD_ID_BRANCH_L
 };
 
 s32 Schedule_RunScript(PlayState* play, ScheduleScript* script, ScheduleOutput* output) {
@@ -291,7 +285,7 @@ s32 Schedule_RunScript(PlayState* play, ScheduleScript* script, ScheduleOutput*
 
     do {
         size = sScheduleCmdSizes[*script];
-        stop = sScheduleCmdFuncs[*script](play, &script, output);
+        stop = sScheduleCmdHandlers[*script](play, &script, output);
         script += size;
     } while (!stop);