Fix another ~200+ crashes that could happen from mods

src/engine/behavior_script.c

@@ -1195,8 +1195,10 @@ static s32 bhv_cmd_load_collision_data_ext(void) {
 void stub_behavior_script_2(void) {
 }
 
+#define BEHAVIOR_CMD_TABLE_MAX 66
+
 typedef s32 (*BhvCommandProc)(void);
-static BhvCommandProc BehaviorCmdTable[] = {
+static BhvCommandProc BehaviorCmdTable[BEHAVIOR_CMD_TABLE_MAX] = {
     bhv_cmd_begin, //00
     bhv_cmd_delay, //01
     bhv_cmd_call,  //02
@@ -1344,7 +1346,11 @@ cur_obj_update_begin:;
     if (!skipBehavior) {
         do {
             if (!gCurBhvCommand) { break; }
-            bhvCmdProc = BehaviorCmdTable[*gCurBhvCommand >> 24];
+
+            u32 index = *gCurBhvCommand >> 24;
+            if (index >= BEHAVIOR_CMD_TABLE_MAX) { break; }
+
+            bhvCmdProc = BehaviorCmdTable[index];
             bhvProcResult = bhvCmdProc();
         } while (bhvProcResult == BHV_PROC_CONTINUE);
     }

src/game/behaviors/collide_particles.inc.c

@@ -56,7 +56,9 @@ void bhv_tiny_star_particles_init(void) {
     for (i = 0; i < 7; i++) {
         particle = spawn_object(o, MODEL_CARTOON_STAR, bhvWallTinyStarParticle);
         if (particle == NULL) { continue; }
-        particle->oMoveAngleYaw = o->parentObj->oMoveAngleYaw + D_8032F2E4[2 * i] + 0x8000;
+        if (o->parentObj) {
+            particle->oMoveAngleYaw = o->parentObj->oMoveAngleYaw + D_8032F2E4[2 * i] + 0x8000;
+        }
         particle->oVelY = sins(D_8032F2E4[2 * i + 1]) * 25.0f;
         particle->oForwardVel = coss(D_8032F2E4[2 * i + 1]) * 25.0f;
     }

src/game/behaviors/fish.inc.c

@@ -80,6 +80,7 @@ void bhv_fish_spawner_loop(void) {
  * Allows the fish to swim vertically.
  */
 static void fish_vertical_roam(s32 speed) {
+    if (!o->parentObj) { return; }
     f32 parentY = o->parentObj->oPosY;
 
     // If the stage is Secret Aquarium, the fish can 

src/game/behaviors/scuttlebug.inc.c

@@ -13,6 +13,7 @@ struct ObjectHitbox sScuttlebugHitbox = {
 };
 
 s32 update_angle_from_move_flags(s32 *angle) {
+    if (!angle) { return 0; }
     if (o->oMoveFlags & OBJ_MOVE_HIT_WALL) {
         *angle = o->oWallAngle;
         return 1;

src/game/camera.c

@@ -4123,6 +4123,7 @@ s32 is_within_100_units_of_mario(f32 posX, f32 posY, f32 posZ) {
 }
 
 s32 set_or_approach_f32_asymptotic(f32 *dst, f32 goal, f32 scale) {
+    if (!dst) { return FALSE; }
     if (sStatusFlags & CAM_FLAG_SMOOTH_MOVEMENT) {
         approach_f32_asymptotic_bool(dst, goal, scale);
     } else {
@@ -4141,6 +4142,7 @@ s32 set_or_approach_f32_asymptotic(f32 *dst, f32 goal, f32 scale) {
  * Edits the current value directly, returns TRUE if the target has been reached, FALSE otherwise.
  */
 s32 approach_f32_asymptotic_bool(f32 *current, f32 target, f32 multiplier) {
+    if (!current) { return FALSE; }
     if (multiplier > 1.f) {
         multiplier = 1.f;
     }
@@ -4166,6 +4168,7 @@ f32 approach_f32_asymptotic(f32 current, f32 target, f32 multiplier) {
  * reciprocal of what it would be in the previous two functions.
  */
 s32 approach_s16_asymptotic_bool(s16 *current, s16 target, s16 divisor) {
+    if (!current) { return FALSE; }
     s16 temp = *current;
 
     if (divisor == 0) {
@@ -4232,6 +4235,7 @@ void approach_vec3s_asymptotic(Vec3s current, Vec3s target, s16 xMul, s16 yMul,
 }
 
 s32 camera_approach_s16_symmetric_bool(s16 *current, s16 target, s16 increment) {
+    if (!current) { return FALSE; }
     s16 dist = target - *current;
 
     if (increment < 0) {
@@ -4284,6 +4288,7 @@ s32 camera_approach_s16_symmetric(s16 current, s16 target, s16 increment) {
 }
 
 s32 set_or_approach_s16_symmetric(s16 *current, s16 target, s16 increment) {
+    if (!current) { return FALSE; }
     if (sStatusFlags & CAM_FLAG_SMOOTH_MOVEMENT) {
         camera_approach_s16_symmetric_bool(current, target, increment);
     } else {
@@ -4302,6 +4307,7 @@ s32 set_or_approach_s16_symmetric(s16 *current, s16 target, s16 increment) {
  * It could possibly be an older version of the function
  */
 s32 camera_approach_f32_symmetric_bool(f32 *current, f32 target, f32 increment) {
+    if (!current) { return FALSE; }
     f32 dist = target - *current;
 
     if (increment < 0) {
@@ -5098,7 +5104,8 @@ s32 trigger_cutscene_dialog(s32 trigger) {
  * Updates the camera based on which C buttons are pressed this frame
  */
 void handle_c_button_movement(struct Camera *c) {
-    s16 cSideYaw;
+    if (!c) { return; }
+    s16 cSideYaw = 0;
 
     // Zoom in
     if ((sCurrPlayMode != PLAY_MODE_PAUSED) && gPlayer1Controller->buttonPressed & U_CBUTTONS) {
@@ -5238,9 +5245,8 @@ u8 open_door_cutscene(u8 pullResult, u8 pushResult) {
  * @return the cutscene that should start, 0 if none
  */
 u8 get_cutscene_from_mario_status(struct Camera *c) {
-    UNUSED u8 unused1[4];
+    if (!c) { return 0; }
     u8 cutscene = c->cutscene;
-    UNUSED u8 unused2[12];
 
     if (cutscene == 0) {
         // A cutscene started by an object, if any, will start if nothing else happened
@@ -5621,6 +5627,7 @@ static UNUSED void stop_transitional_movement(void) {
  * @return TRUE if the base pos was updated
  */
 s32 set_camera_mode_fixed(struct Camera *c, s16 x, s16 y, s16 z) {
+    if (!c) { return FALSE; }
     s32 basePosSet = FALSE;
     f32 posX = x;
     f32 posY = y;
@@ -5643,6 +5650,7 @@ s32 set_camera_mode_fixed(struct Camera *c, s16 x, s16 y, s16 z) {
 }
 
 void set_camera_mode_8_directions(struct Camera *c) {
+    if (!c) { return; }
     if (c->mode != CAMERA_MODE_8_DIRECTIONS) {
         c->mode = CAMERA_MODE_8_DIRECTIONS;
         sStatusFlags &= ~CAM_FLAG_SMOOTH_MOVEMENT;
@@ -5660,6 +5668,7 @@ void set_camera_mode_8_directions(struct Camera *c) {
  * set it to be so.
  */
 void set_camera_mode_boss_fight(struct Camera *c) {
+    if (!c) { return; }
     if (c->mode != CAMERA_MODE_BOSS_FIGHT) {
         transition_to_camera_mode(c, CAMERA_MODE_BOSS_FIGHT, 15);
         sModeOffsetYaw = c->nextYaw - DEGREES(45);
@@ -5667,6 +5676,7 @@ void set_camera_mode_boss_fight(struct Camera *c) {
 }
 
 void set_camera_mode_close_cam(u8 *mode) {
+    if (!mode) { return; }
     if (*mode != CAMERA_MODE_CLOSE) {
         sStatusFlags &= ~CAM_FLAG_SMOOTH_MOVEMENT;
         *mode = CAMERA_MODE_CLOSE;
@@ -5683,6 +5693,7 @@ void set_camera_mode_close_cam(u8 *mode) {
  * Otherwise jump to radial mode.
  */
 void set_camera_mode_radial(struct Camera *c, s16 transitionTime) {
+    if (!c) { return; }
     Vec3f focus;
     s16 yaw;
 
@@ -5709,6 +5720,7 @@ void set_camera_mode_radial(struct Camera *c, s16 transitionTime) {
  * Start parallel tracking mode using the path `path`
  */
 void parallel_tracking_init(struct Camera *c, struct ParallelTrackingPoint *path) {
+    if (!c) { return; }
     if (c->mode != CAMERA_MODE_PARALLEL_TRACKING) {
         sParTrackPath = path;
         sParTrackIndex = 0;
@@ -5758,10 +5770,12 @@ void check_blocking_area_processing(const u8 *mode) {
         sStatusFlags &= ~CAM_FLAG_BLOCK_AREA_PROCESSING;
     }
 
-    if ((*mode == CAMERA_MODE_BEHIND_MARIO &&
+    if (mode) {
-            !(sMarioCamState->action & (ACT_FLAG_SWIMMING | ACT_FLAG_METAL_WATER))) ||
+        if ((*mode == CAMERA_MODE_BEHIND_MARIO &&
-         *mode == CAMERA_MODE_INSIDE_CANNON) {
+                !(sMarioCamState->action & (ACT_FLAG_SWIMMING | ACT_FLAG_METAL_WATER))) ||
-        sStatusFlags |= CAM_FLAG_BLOCK_AREA_PROCESSING;
+            *mode == CAMERA_MODE_INSIDE_CANNON) {
+            sStatusFlags |= CAM_FLAG_BLOCK_AREA_PROCESSING;
+        }
     }
 }
 
@@ -5772,7 +5786,7 @@ BAD_RETURN(s32) cam_rr_exit_building_side(struct Camera *c) {
 
 BAD_RETURN(s32) cam_rr_exit_building_top(struct Camera *c) {
     set_camera_mode_8_directions(c);
-    if (c->pos[1] < 6343.f) {
+    if (c && c->pos[1] < 6343.f) {
         c->pos[1] = 7543.f;
         gLakituState.goalPos[1] = c->pos[1];
         gLakituState.curPos[1] = c->pos[1];
@@ -5781,12 +5795,13 @@ BAD_RETURN(s32) cam_rr_exit_building_top(struct Camera *c) {
 }
 
 BAD_RETURN(s32) cam_rr_enter_building_window(struct Camera *c) {
-    if (c->mode != CAMERA_MODE_FIXED) {
+    if (c && c->mode != CAMERA_MODE_FIXED) {
         set_camera_mode_fixed(c, -2974, 478, -3975);
     }
 }
 
 BAD_RETURN(s32) cam_rr_enter_building(struct Camera *c) {
+    if (!c) { return; }
     if (c->mode != CAMERA_MODE_FIXED) {
         set_camera_mode_fixed(c, -2953, 798, -3943);
     }
@@ -5797,6 +5812,7 @@ BAD_RETURN(s32) cam_rr_enter_building(struct Camera *c) {
 }
 
 BAD_RETURN(s32) cam_rr_enter_building_side(struct Camera *c) {
+    if (!c) { return; }
     if (c->mode != CAMERA_MODE_FIXED) {
         sStatusFlags &= ~CAM_FLAG_SMOOTH_MOVEMENT;
         c->mode = CAMERA_MODE_FIXED;
@@ -5808,6 +5824,7 @@ BAD_RETURN(s32) cam_rr_enter_building_side(struct Camera *c) {
  * Fix the camera in place as Mario gets exits out the MC cave into the waterfall.
  */
 BAD_RETURN(s32) cam_cotmc_exit_waterfall(UNUSED struct Camera *c) {
+    if (!c) { return; }
     gCameraMovementFlags |= CAM_MOVE_FIX_IN_PLACE;
 }
 
@@ -5816,6 +5833,7 @@ BAD_RETURN(s32) cam_cotmc_exit_waterfall(UNUSED struct Camera *c) {
  * Activated when Mario is walking in front of the snowman's head.
  */
 BAD_RETURN(s32) cam_sl_snowman_head_8dir(struct Camera *c) {
+    if (!c) { return; }
     sStatusFlags |= CAM_FLAG_BLOCK_AREA_PROCESSING;
     transition_to_camera_mode(c, CAMERA_MODE_8_DIRECTIONS, 60);
     s8DirModeBaseYaw = 0x1D27;
@@ -5826,6 +5844,7 @@ BAD_RETURN(s32) cam_sl_snowman_head_8dir(struct Camera *c) {
  * trigger.
  */
 BAD_RETURN(s32) cam_sl_free_roam(struct Camera *c) {
+    if (!c) { return; }
     transition_to_camera_mode(c, CAMERA_MODE_FREE_ROAM, 60);
 }
 
@@ -5833,6 +5852,7 @@ BAD_RETURN(s32) cam_sl_free_roam(struct Camera *c) {
  * Warps the camera underneath the floor, used in HMC to move under the elevator platforms
  */
 void move_camera_through_floor_while_descending(struct Camera *c, f32 height) {
+    if (!c) { return; }
     UNUSED f32 pad;
 
     if ((sMarioGeometry.currFloorHeight < height - 100.f)
@@ -5844,6 +5864,7 @@ void move_camera_through_floor_while_descending(struct Camera *c, f32 height) {
 }
 
 BAD_RETURN(s32) cam_hmc_enter_maze(struct Camera *c) {
+    if (!c) { return; }
     s16 pitch, yaw;
     f32 dist;
 
@@ -5860,18 +5881,22 @@ BAD_RETURN(s32) cam_hmc_enter_maze(struct Camera *c) {
 }
 
 BAD_RETURN(s32) cam_hmc_elevator_black_hole(struct Camera *c) {
+    if (!c) { return; }
     move_camera_through_floor_while_descending(c, 1536.f);
 }
 
 BAD_RETURN(s32) cam_hmc_elevator_maze_emergency_exit(struct Camera *c) {
+    if (!c) { return; }
     move_camera_through_floor_while_descending(c, 2355.f);
 }
 
 BAD_RETURN(s32) cam_hmc_elevator_lake(struct Camera *c) {
+    if (!c) { return; }
     move_camera_through_floor_while_descending(c, 1843.f);
 }
 
 BAD_RETURN(s32) cam_hmc_elevator_maze(struct Camera *c) {
+    if (!c) { return; }
     move_camera_through_floor_while_descending(c, 1843.f);
 }
 
@@ -5879,6 +5904,7 @@ BAD_RETURN(s32) cam_hmc_elevator_maze(struct Camera *c) {
  * Starts the "Enter Pyramid Top" cutscene.
  */
 BAD_RETURN(s32) cam_ssl_enter_pyramid_top(UNUSED struct Camera *c) {
+    if (!c) { return; }
     start_object_cutscene_without_focus(CUTSCENE_ENTER_PYRAMID_TOP);
 }
 
@@ -5887,6 +5913,7 @@ BAD_RETURN(s32) cam_ssl_enter_pyramid_top(UNUSED struct Camera *c) {
  * radial.
  */
 BAD_RETURN(s32) cam_ssl_pyramid_center(struct Camera *c) {
+    if (!c) { return; }
     sStatusFlags |= CAM_FLAG_BLOCK_AREA_PROCESSING;
     transition_to_camera_mode(c, CAMERA_MODE_CLOSE, 90);
 }
@@ -5895,6 +5922,7 @@ BAD_RETURN(s32) cam_ssl_pyramid_center(struct Camera *c) {
  * Changes the mode back to outward radial in the boss room inside the pyramid.
  */
 BAD_RETURN(s32) cam_ssl_boss_room(struct Camera *c) {
+    if (!c) { return; }
     sStatusFlags |= CAM_FLAG_BLOCK_AREA_PROCESSING;
     transition_to_camera_mode(c, CAMERA_MODE_OUTWARD_RADIAL, 90);
 }
@@ -5903,6 +5931,7 @@ BAD_RETURN(s32) cam_ssl_boss_room(struct Camera *c) {
  * Moves the camera to through the tunnel by forcing sModeOffsetYaw
  */
 BAD_RETURN(s32) cam_thi_move_cam_through_tunnel(UNUSED struct Camera *c) {
+    if (!c) { return; }
     if (sModeOffsetYaw < DEGREES(60)) {
         sModeOffsetYaw = DEGREES(60);
     }
@@ -5912,6 +5941,7 @@ BAD_RETURN(s32) cam_thi_move_cam_through_tunnel(UNUSED struct Camera *c) {
  * Aligns the camera to look through the tunnel
  */
 BAD_RETURN(s32) cam_thi_look_through_tunnel(UNUSED struct Camera *c) {
+    if (!c) { return; }
     // ~82.5 degrees
     if (sModeOffsetYaw > 0x3AAA) {
         sModeOffsetYaw = 0x3AAA;
@@ -5924,6 +5954,7 @@ BAD_RETURN(s32) cam_thi_look_through_tunnel(UNUSED struct Camera *c) {
  * @see sCamBOB for bounds.
  */
 BAD_RETURN(s32) cam_bob_tower(struct Camera *c) {
+    if (!c) { return; }
     sStatusFlags |= CAM_FLAG_BLOCK_AREA_PROCESSING;
     transition_to_camera_mode(c, CAMERA_MODE_RADIAL, 90);
 }
@@ -5937,6 +5968,7 @@ BAD_RETURN(s32) cam_bob_tower(struct Camera *c) {
  * @see sCamBOB
  */
 BAD_RETURN(s32) cam_bob_default_free_roam(struct Camera *c) {
+    if (!c) { return; }
     transition_to_camera_mode(c, CAMERA_MODE_FREE_ROAM, 90);
 }
 
@@ -5945,6 +5977,7 @@ BAD_RETURN(s32) cam_bob_default_free_roam(struct Camera *c) {
  * Used in both the castle and HMC.
  */
 BAD_RETURN(s32) cam_castle_hmc_start_pool_cutscene(struct Camera *c) {
+    if (!c) { return; }
     if ((sMarioCamState->action != ACT_SPECIAL_DEATH_EXIT)
         && (sMarioCamState->action != ACT_SPECIAL_EXIT_AIRBORNE)) {
         start_cutscene(c, CUTSCENE_ENTER_POOL);
@@ -5956,6 +5989,7 @@ BAD_RETURN(s32) cam_castle_hmc_start_pool_cutscene(struct Camera *c) {
  * to the castle lobby
  */
 BAD_RETURN(s32) cam_castle_lobby_entrance(UNUSED struct Camera *c) {
+    if (!c) { return; }
     vec3f_set(sCastleEntranceOffset, -813.f - sFixedModeBasePosition[0],
               378.f - sFixedModeBasePosition[1], 1103.f - sFixedModeBasePosition[2]);
 }
@@ -5964,6 +5998,7 @@ BAD_RETURN(s32) cam_castle_lobby_entrance(UNUSED struct Camera *c) {
  * Make the camera look up the stairs from the 2nd to 3rd floor of the castle
  */
 BAD_RETURN(s32) cam_castle_look_upstairs(struct Camera *c) {
+    if (!c) { return; }
     struct Surface *floor;
     f32 floorHeight = find_floor(c->pos[0], c->pos[1], c->pos[2], &floor);
 
@@ -5978,6 +6013,7 @@ BAD_RETURN(s32) cam_castle_look_upstairs(struct Camera *c) {
  * Make the camera look down the stairs towards the basement star door
  */
 BAD_RETURN(s32) cam_castle_basement_look_downstairs(struct Camera *c) {
+    if (!c) { return; }
     struct Surface *floor;
     f32 floorHeight = find_floor(c->pos[0], c->pos[1], c->pos[2], &floor);
 
@@ -5992,6 +6028,7 @@ BAD_RETURN(s32) cam_castle_basement_look_downstairs(struct Camera *c) {
  * changes to fixed mode.
  */
 BAD_RETURN(s32) cam_castle_enter_lobby(struct Camera *c) {
+    if (!c) { return; }
     if (c->mode != CAMERA_MODE_FIXED) {
         sStatusFlags &= ~CAM_FLAG_SMOOTH_MOVEMENT;
         set_fixed_cam_axis_sa_lobby(c->mode);
@@ -6004,6 +6041,7 @@ BAD_RETURN(s32) cam_castle_enter_lobby(struct Camera *c) {
  * Starts spiral stairs mode.
  */
 BAD_RETURN(s32) cam_castle_enter_spiral_stairs(struct Camera *c) {
+    if (!c) { return; }
     transition_to_camera_mode(c, CAMERA_MODE_SPIRAL_STAIRS, 20);
 }
 
@@ -6012,6 +6050,7 @@ BAD_RETURN(s32) cam_castle_enter_spiral_stairs(struct Camera *c) {
  * This was replaced with cam_castle_close_mode
  */
 static UNUSED BAD_RETURN(s32) cam_castle_leave_spiral_stairs(struct Camera *c) {
+    if (!c) { return; }
     if (c->mode == CAMERA_MODE_SPIRAL_STAIRS) {
         transition_to_camera_mode(c, CAMERA_MODE_CLOSE, 30);
     } else {
@@ -6024,6 +6063,7 @@ static UNUSED BAD_RETURN(s32) cam_castle_leave_spiral_stairs(struct Camera *c) {
  * every door leaving the lobby and spiral staircase.
  */
 BAD_RETURN(s32) cam_castle_close_mode(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_close_cam(&c->mode);
 }
 
@@ -6032,6 +6072,7 @@ BAD_RETURN(s32) cam_castle_close_mode(struct Camera *c) {
  * fixed-mode when Mario leaves the room.
  */
 BAD_RETURN(s32) cam_castle_leave_lobby_sliding_door(struct Camera *c) {
+    if (!c) { return; }
     cam_castle_close_mode(c);
     c->doorStatus = DOOR_ENTER_LOBBY;
 }
@@ -6040,18 +6081,22 @@ BAD_RETURN(s32) cam_castle_leave_lobby_sliding_door(struct Camera *c) {
  * Just calls cam_castle_enter_lobby
  */
 BAD_RETURN(s32) cam_castle_enter_lobby_sliding_door(struct Camera *c) {
+    if (!c) { return; }
     cam_castle_enter_lobby(c);
 }
 
 BAD_RETURN(s32) cam_bbh_room_6(struct Camera *c) {
+    if (!c) { return; }
     parallel_tracking_init(c, sBBHLibraryParTrackPath);
 }
 
 BAD_RETURN(s32) cam_bbh_fall_off_roof(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_close_cam(&c->mode);
 }
 
 BAD_RETURN(s32) cam_bbh_fall_into_pool(struct Camera *c) {
+    if (!c) { return; }
     Vec3f dir;
     set_camera_mode_close_cam(&c->mode);
     vec3f_set(dir, 0.f, 0.f, 300.f);
@@ -6062,23 +6107,28 @@ BAD_RETURN(s32) cam_bbh_fall_into_pool(struct Camera *c) {
 }
 
 BAD_RETURN(s32) cam_bbh_room_1(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, 956, 440, 1994);
 }
 
 BAD_RETURN(s32) cam_bbh_leave_front_door(struct Camera *c) {
+    if (!c) { return; }
     c->doorStatus = DOOR_LEAVING_SPECIAL;
     cam_bbh_room_1(c);
 }
 
 BAD_RETURN(s32) cam_bbh_room_2_lower(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, 2591, 400, 1284);
 }
 
 BAD_RETURN(s32) cam_bbh_room_4(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, 3529, 340, -1384);
 }
 
 BAD_RETURN(s32) cam_bbh_room_8(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, -500, 740, -1306);
 }
 
@@ -6087,6 +6137,7 @@ BAD_RETURN(s32) cam_bbh_room_8(struct Camera *c) {
  * set the camera mode to fixed and position to (-2172, 200, 675)
  */
 BAD_RETURN(s32) cam_bbh_room_5_library(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, -2172, 200, 675);
 }
 
@@ -6096,52 +6147,62 @@ BAD_RETURN(s32) cam_bbh_room_5_library(struct Camera *c) {
  * if coming from the library.
  */
 BAD_RETURN(s32) cam_bbh_room_5_library_to_hidden_transition(struct Camera *c) {
+    if (!c) { return; }
     if (set_camera_mode_fixed(c, -2172, 200, 675) == 1) {
         transition_next_state(c, 20);
     }
 }
 
 BAD_RETURN(s32) cam_bbh_room_5_hidden_to_library_transition(struct Camera *c) {
+    if (!c) { return; }
     if (set_camera_mode_fixed(c, -1542, 320, -307) == 1) {
         transition_next_state(c, 20);
     }
 }
 
 BAD_RETURN(s32) cam_bbh_room_5_hidden(struct Camera *c) {
+    if (!c) { return; }
     c->doorStatus = DOOR_LEAVING_SPECIAL;
     set_camera_mode_fixed(c, -1542, 320, -307);
 }
 
 BAD_RETURN(s32) cam_bbh_room_3(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, -1893, 320, 2327);
 }
 
 BAD_RETURN(s32) cam_bbh_room_7_mr_i(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, 1371, 360, -1302);
 }
 
 BAD_RETURN(s32) cam_bbh_room_7_mr_i_to_coffins_transition(struct Camera *c) {
+    if (!c) { return; }
     if (set_camera_mode_fixed(c, 1371, 360, -1302) == 1) {
         transition_next_state(c, 20);
     }
 }
 
 BAD_RETURN(s32) cam_bbh_room_7_coffins_to_mr_i_transition(struct Camera *c) {
+    if (!c) { return; }
     if (set_camera_mode_fixed(c, 2115, 260, -772) == 1) {
         transition_next_state(c, 20);
     }
 }
 
 BAD_RETURN(s32) cam_bbh_elevator_room_lower(struct Camera *c) {
+    if (!c) { return; }
     c->doorStatus = DOOR_LEAVING_SPECIAL;
     set_camera_mode_close_cam(&c->mode);
 }
 
 BAD_RETURN(s32) cam_bbh_room_0_back_entrance(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_close_cam(&c->mode);
 }
 
 BAD_RETURN(s32) cam_bbh_elevator(struct Camera *c) {
+    if (!c) { return; }
     if (c->mode == CAMERA_MODE_FIXED) {
         set_camera_mode_close_cam(&c->mode);
         c->pos[1] = -405.f;
@@ -6150,55 +6211,66 @@ BAD_RETURN(s32) cam_bbh_elevator(struct Camera *c) {
 }
 
 BAD_RETURN(s32) cam_bbh_room_12_upper(struct Camera *c) {
+    if (!c) { return; }
     c->doorStatus = DOOR_LEAVING_SPECIAL;
     set_camera_mode_fixed(c, -2932, 296, 4429);
 }
 
 BAD_RETURN(s32) cam_bbh_enter_front_door(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_close_cam(&c->mode);
 }
 
 BAD_RETURN(s32) cam_bbh_room_2_library(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, 3493, 440, 617);
 }
 
 BAD_RETURN(s32) cam_bbh_room_2_library_to_trapdoor_transition(struct Camera *c) {
+    if (!c) { return; }
     if (set_camera_mode_fixed(c, 3493, 440, 617) == 1) {
         transition_next_state(c, 20);
     }
 }
 
 BAD_RETURN(s32) cam_bbh_room_2_trapdoor(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, 3502, 440, 1217);
 }
 
 BAD_RETURN(s32) cam_bbh_room_2_trapdoor_transition(struct Camera *c) {
+    if (!c) { return; }
     if (set_camera_mode_fixed(c, 3502, 440, 1217) == 1) {
         transition_next_state(c, 20);
     }
 }
 
 BAD_RETURN(s32) cam_bbh_room_9_attic(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, -670, 460, 372);
 }
 
 BAD_RETURN(s32) cam_bbh_room_9_attic_transition(struct Camera *c) {
+    if (!c) { return; }
     if (set_camera_mode_fixed(c, -670, 460, 372) == 1) {
         transition_next_state(c, 20);
     }
 }
 
 BAD_RETURN(s32) cam_bbh_room_9_mr_i_transition(struct Camera *c) {
+    if (!c) { return; }
     if (set_camera_mode_fixed(c, 131, 380, -263) == 1) {
         transition_next_state(c, 20);
     }
 }
 
 BAD_RETURN(s32) cam_bbh_room_13_balcony(struct Camera *c) {
+    if (!c) { return; }
     set_camera_mode_fixed(c, 210, 420, 3109);
 }
 
 BAD_RETURN(s32) cam_bbh_room_0(struct Camera *c) {
+    if (!c) { return; }
     c->doorStatus = DOOR_LEAVING_SPECIAL;
     set_camera_mode_fixed(c, -204, 807, 204);
 }
@@ -6215,6 +6287,7 @@ BAD_RETURN(s32) cam_ccm_leave_slide_shortcut(UNUSED struct Camera *c) {
  * Apply any modes that are triggered by special floor surface types
  */
 u32 surface_type_modes(struct Camera *c) {
+    if (!c) { return 0; }
     u32 modeChanged = 0;
 
     switch (sMarioGeometry.currFloorType) {
@@ -6650,6 +6723,7 @@ static struct CameraTrigger* get_camera_trigger(s16 levelNum) {
  * @return the camera's mode after processing, although this is unused in the code
  */
 s16 camera_course_processing(struct Camera *c) {
+    if (!c) { return 0; }
     if (!gCameraUseCourseSpecificSettings) { return 0; }
     s16 level = gCurrLevelNum;
     s16 mode;
@@ -6977,7 +7051,8 @@ s32 rotate_camera_around_walls(struct Camera *c, Vec3f cPos, s16 *avoidYaw, s16
  * Note: Also finds the water level, but waterHeight is unused
  */
 void find_mario_floor_and_ceil(struct PlayerGeometry *pg) {
-    struct Surface *surf;
+    if (!pg) { return; }
+    struct Surface *surf = NULL;
     s16 tempCheckingSurfaceCollisionsForCamera = gCheckingSurfaceCollisionsForCamera;
     gCheckingSurfaceCollisionsForCamera = TRUE;
 

src/game/interaction.c

@@ -322,6 +322,7 @@ void mario_grab_used_object(struct MarioState *m) {
 }
 
 void mario_drop_held_object(struct MarioState *m) {
+    if (!m) { return; }
     if (m->playerIndex != 0) { return; }
 
     if (m->heldObj != NULL) {
@@ -351,6 +352,7 @@ void mario_drop_held_object(struct MarioState *m) {
 }
 
 void mario_throw_held_object(struct MarioState *m) {
+    if (!m) { return; }
     if (m->playerIndex != 0) { return; }
 
     if (m->heldObj != NULL) {
@@ -377,6 +379,7 @@ void mario_throw_held_object(struct MarioState *m) {
 }
 
 void mario_stop_riding_and_holding(struct MarioState *m) {
+    if (!m) { return; }
     mario_drop_held_object(m);
     mario_stop_riding_object(m);
 
@@ -387,10 +390,12 @@ void mario_stop_riding_and_holding(struct MarioState *m) {
 }
 
 u32 does_mario_have_normal_cap_on_head(struct MarioState *m) {
+    if (!m) { return FALSE; }
     return (m->flags & (MARIO_CAPS | MARIO_CAP_ON_HEAD)) == (MARIO_NORMAL_CAP | MARIO_CAP_ON_HEAD);
 }
 
 void mario_blow_off_cap(struct MarioState *m, f32 capSpeed) {
+    if (!m) { return; }
     if (m->playerIndex != 0) { return; }
     struct Object *capObject;
 
@@ -423,6 +428,7 @@ void mario_blow_off_cap(struct MarioState *m, f32 capSpeed) {
 }
 
 u32 mario_lose_cap_to_enemy(struct MarioState* m, u32 arg) {
+    if (!m) { return FALSE; }
     if (m->playerIndex != 0) { return FALSE; }
     u32 wasWearingCap = FALSE;
 
@@ -436,6 +442,7 @@ u32 mario_lose_cap_to_enemy(struct MarioState* m, u32 arg) {
 }
 
 void mario_retrieve_cap(struct MarioState* m) {
+    if (!m) { return; }
     mario_drop_held_object(m);
     save_file_clear_flags(SAVE_FLAG_CAP_ON_KLEPTO | SAVE_FLAG_CAP_ON_UKIKI);
     m->flags &= ~MARIO_CAP_ON_HEAD;
@@ -443,6 +450,7 @@ void mario_retrieve_cap(struct MarioState* m) {
 }
 
 u32 able_to_grab_object(struct MarioState *m, UNUSED struct Object *o) {
+    if (!m || !o) { return FALSE; }
     u32 action = m->action;
 
     if (action == ACT_DIVE_SLIDE || action == ACT_DIVE) {

src/game/mario.c

@@ -84,6 +84,7 @@ s32 is_anim_past_end(struct MarioState *m) {
  * Sets Mario's animation without any acceleration, running at its default rate.
  */
 s16 set_mario_animation(struct MarioState *m, s32 targetAnimID) {
+    if (!m) { return 0; }
     struct Object *o = m->marioObj;
     if (!o || !m->animation) { return 0; }
     struct Animation *targetAnim = m->animation->targetAnim;
@@ -298,6 +299,7 @@ void play_mario_jump_sound(struct MarioState *m) {
  * Adjusts the volume/pitch of sounds from Mario's speed.
  */
 void adjust_sound_for_speed(struct MarioState *m) {
+    if (!m) { return; }
     s32 absForwardVel = (m->forwardVel > 0.0f) ? m->forwardVel : -m->forwardVel;
     set_sound_moving_speed(SOUND_BANK_MOVING, (absForwardVel > 100) ? 100 : absForwardVel);
 }
@@ -306,6 +308,7 @@ void adjust_sound_for_speed(struct MarioState *m) {
  * Spawns particles if the step sound says to, then either plays a step sound or relevant other sound.
  */
 void play_sound_and_spawn_particles(struct MarioState *m, u32 soundBits, u32 waveParticleType) {
+    if (!m) { return; }
     if (m->terrainSoundAddend == (SOUND_TERRAIN_WATER << 16)) {
         if (waveParticleType != 0) {
             set_mario_particle_flags(m, PARTICLE_SHALLOW_WATER_SPLASH, FALSE);
@@ -336,6 +339,7 @@ void play_sound_and_spawn_particles(struct MarioState *m, u32 soundBits, u32 wav
  * Plays an environmental sound if one has not been played since the last action change.
  */
 void play_mario_action_sound(struct MarioState *m, u32 soundBits, u32 waveParticleType) {
+    if (!m) { return; }
     if (!(m->flags & MARIO_ACTION_SOUND_PLAYED)) {
         play_sound_and_spawn_particles(m, soundBits, waveParticleType);
         m->flags |= MARIO_ACTION_SOUND_PLAYED;
@@ -346,6 +350,7 @@ void play_mario_action_sound(struct MarioState *m, u32 soundBits, u32 wavePartic
  * Plays a landing sound, accounting for metal cap.
  */
 void play_mario_landing_sound(struct MarioState *m, u32 soundBits) {
+    if (!m) { return; }
     play_sound_and_spawn_particles(
         m, (m->flags & MARIO_METAL_CAP) ? SOUND_ACTION_METAL_LANDING : soundBits, 1);
 }
@@ -356,6 +361,7 @@ void play_mario_landing_sound(struct MarioState *m, u32 soundBits) {
  * played once per action.
  */
 void play_mario_landing_sound_once(struct MarioState *m, u32 soundBits) {
+    if (!m) { return; }
     play_mario_action_sound(
         m, (m->flags & MARIO_METAL_CAP) ? SOUND_ACTION_METAL_LANDING : soundBits, 1);
 }
@@ -364,6 +370,7 @@ void play_mario_landing_sound_once(struct MarioState *m, u32 soundBits) {
  * Plays a heavy landing (ground pound, etc.) sound, accounting for metal cap.
  */
 void play_mario_heavy_landing_sound(struct MarioState *m, u32 soundBits) {
+    if (!m) { return; }
     play_sound_and_spawn_particles(
         m, (m->flags & MARIO_METAL_CAP) ? SOUND_ACTION_METAL_HEAVY_LANDING : soundBits, 1);
 }
@@ -374,6 +381,7 @@ void play_mario_heavy_landing_sound(struct MarioState *m, u32 soundBits) {
  * making sure the sound is only played once per action.
  */
 void play_mario_heavy_landing_sound_once(struct MarioState *m, u32 soundBits) {
+    if (!m) { return; }
     play_mario_action_sound(
         m, (m->flags & MARIO_METAL_CAP) ? SOUND_ACTION_METAL_HEAVY_LANDING : soundBits, 1);
 }
@@ -382,6 +390,7 @@ void play_mario_heavy_landing_sound_once(struct MarioState *m, u32 soundBits) {
  * Plays action and Mario sounds relevant to what was passed into the function.
  */
 void play_mario_sound(struct MarioState *m, s32 actionSound, s32 marioSound) {
+    if (!m) { return; }
     if (actionSound == SOUND_ACTION_TERRAIN_JUMP) {
         play_mario_action_sound(m, (m->flags & MARIO_METAL_CAP) ? (s32) SOUND_ACTION_METAL_JUMP
                                                                 : (s32) SOUND_ACTION_TERRAIN_JUMP, 1);
@@ -403,6 +412,7 @@ void play_mario_sound(struct MarioState *m, s32 actionSound, s32 marioSound) {
  **************************************************/
 
 bool mario_can_bubble(struct MarioState* m) {
+    if (!m) { return false; }
     if (!gServerSettings.bubbleDeath) { return false; }
     if (m->playerIndex != 0) { return false; }
     if (m->action == ACT_BUBBLED) { return false; }
@@ -422,6 +432,7 @@ bool mario_can_bubble(struct MarioState* m) {
 }
 
 void mario_set_bubbled(struct MarioState* m) {
+    if (!m) { return; }
     if (m->playerIndex != 0) { return; }
     if (m->action == ACT_BUBBLED) { return; }
 
@@ -450,6 +461,7 @@ void mario_set_bubbled(struct MarioState* m) {
  * Sets Mario's other velocities from his forward speed.
  */
 void mario_set_forward_vel(struct MarioState *m, f32 forwardVel) {
+    if (!m) { return; }
     m->forwardVel = forwardVel;
 
     m->slideVelX = sins(m->faceAngle[1]) * m->forwardVel;
@@ -463,6 +475,7 @@ void mario_set_forward_vel(struct MarioState *m, f32 forwardVel) {
  * Returns the slipperiness class of Mario's floor.
  */
 s32 mario_get_floor_class(struct MarioState *m) {
+    if (!m) { return SURFACE_CLASS_NOT_SLIPPERY; }
     s32 floorClass;
 
     // The slide terrain type defaults to slide slipperiness.
@@ -535,6 +548,7 @@ s8 sTerrainSounds[7][6] = {
  * This depends on surfaces and terrain.
  */
 u32 mario_get_terrain_sound_addend(struct MarioState *m) {
+    if (!m) { return SURFACE_CLASS_NOT_SLIPPERY; }
     s16 floorSoundType;
     s16 terrainType = m->area->terrainType & TERRAIN_MASK;
     s32 ret = SOUND_TERRAIN_DEFAULT << 16;
@@ -782,6 +796,7 @@ s32 mario_floor_is_steep(struct MarioState *m) {
  * Finds the floor height relative from Mario given polar displacement.
  */
 f32 find_floor_height_relative_polar(struct MarioState *m, s16 angleFromMario, f32 distFromMario) {
+    if (!m) { return 0; }
     struct Surface *floor;
     f32 floorY;
 
@@ -797,6 +812,7 @@ f32 find_floor_height_relative_polar(struct MarioState *m, s16 angleFromMario, f
  * Returns the slope of the floor based off points around Mario.
  */
 s16 find_floor_slope(struct MarioState *m, s16 yawOffset) {
+    if (!m) { return 0; }
     struct Surface *floor;
     f32 forwardFloorY, backwardFloorY;
     f32 forwardYDelta, backwardYDelta;
@@ -826,6 +842,8 @@ s16 find_floor_slope(struct MarioState *m, s16 yawOffset) {
  * Adjusts Mario's camera and sound based on his action status.
  */
 void update_mario_sound_and_camera(struct MarioState *m) {
+    if (!m) { return; }
+
     // only update for local player
     if (m != &gMarioStates[0]) { return; }
 
@@ -858,6 +876,7 @@ void update_mario_sound_and_camera(struct MarioState *m) {
  * Transitions Mario to a steep jump action.
  */
 void set_steep_jump_action(struct MarioState *m) {
+    if (!m) { return; }
     m->marioObj->oMarioSteepJumpYaw = m->faceAngle[1];
 
     if (m->forwardVel > 0.0f) {
@@ -880,6 +899,7 @@ void set_steep_jump_action(struct MarioState *m) {
  * Sets Mario's vertical speed from his forward speed.
  */
 void set_mario_y_vel_based_on_fspeed(struct MarioState *m, f32 initialVelY, f32 multiplier) {
+    if (!m) { return; }
     // get_additive_y_vel_for_jumps is always 0 and a stubbed function.
     // It was likely trampoline related based on code location.
     m->vel[1] = initialVelY + get_additive_y_vel_for_jumps() + m->forwardVel * multiplier;
@@ -1096,6 +1116,7 @@ static u32 set_mario_action_cutscene(struct MarioState *m, u32 action, UNUSED u3
  * specific function if needed.
  */
 u32 set_mario_action(struct MarioState *m, u32 action, u32 actionArg) {
+    if (!m) { return FALSE; }
     u32 returnValue = 0;
     smlua_call_event_hooks_mario_action_params_ret_int(HOOK_BEFORE_SET_MARIO_ACTION, m, action, &returnValue);
     if (returnValue == 1) { return TRUE; } else if (returnValue) { action = returnValue; }
@@ -1141,6 +1162,7 @@ u32 set_mario_action(struct MarioState *m, u32 action, u32 actionArg) {
  * Puts Mario into a specific jumping action from a landing action.
  */
 s32 set_jump_from_landing(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->quicksandDepth >= 11.0f) {
         if (m->heldObj == NULL) {
             return set_mario_action(m, ACT_QUICKSAND_JUMP_LAND, 0);
@@ -1197,6 +1219,7 @@ s32 set_jump_from_landing(struct MarioState *m) {
  * either a quicksand or steep jump.
  */
 s32 set_jumping_action(struct MarioState *m, u32 action, u32 actionArg) {
+    if (!m) { return FALSE; }
     UNUSED u32 currAction = m->action;
 
     if (m->quicksandDepth >= 11.0f) {
@@ -1221,6 +1244,7 @@ s32 set_jumping_action(struct MarioState *m, u32 action, u32 actionArg) {
  * Drop anything Mario is holding and set a new action.
  */
 s32 drop_and_set_mario_action(struct MarioState *m, u32 action, u32 actionArg) {
+    if (!m) { return FALSE; }
     mario_stop_riding_and_holding(m);
 
     return set_mario_action(m, action, actionArg);
@@ -1230,6 +1254,7 @@ s32 drop_and_set_mario_action(struct MarioState *m, u32 action, u32 actionArg) {
  * Increment Mario's hurt counter and set a new action.
  */
 s32 hurt_and_set_mario_action(struct MarioState *m, u32 action, u32 actionArg, s16 hurtCounter) {
+    if (!m) { return FALSE; }
     m->hurtCounter = hurtCounter;
 
     return set_mario_action(m, action, actionArg);
@@ -1240,6 +1265,7 @@ s32 hurt_and_set_mario_action(struct MarioState *m, u32 action, u32 actionArg, s
  * actions. A common variant of the below function.
  */
 s32 check_common_action_exits(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->input & INPUT_A_PRESSED) {
         return set_mario_action(m, ACT_JUMP, 0);
     }
@@ -1261,6 +1287,7 @@ s32 check_common_action_exits(struct MarioState *m) {
  * object holding actions. A holding variant of the above function.
  */
 s32 check_common_hold_action_exits(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->input & INPUT_A_PRESSED) {
         return set_mario_action(m, ACT_HOLD_JUMP, 0);
     }
@@ -1281,6 +1308,7 @@ s32 check_common_hold_action_exits(struct MarioState *m) {
  * Transitions Mario from a submerged action to a walking action.
  */
 s32 transition_submerged_to_walking(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->playerIndex == 0) {
         set_camera_mode(m->area->camera, m->area->camera->defMode, 1);
     }
@@ -1299,6 +1327,7 @@ s32 transition_submerged_to_walking(struct MarioState *m) {
  * non-submerged action. This also applies the water surface camera preset.
  */
 s32 set_water_plunge_action(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->action == ACT_BUBBLED) { return FALSE; }
     if (m->action == ACT_IN_CANNON) { return FALSE; }
 
@@ -1333,6 +1362,7 @@ u8 sSquishScaleOverTime[16] = { 0x46, 0x32, 0x32, 0x3C, 0x46, 0x50, 0x50, 0x3C,
  * Applies the squish to Mario's model via scaling.
  */
 void squish_mario_model(struct MarioState *m) {
+    if (!m) { return; }
     if (m->squishTimer == 0xFF && m->bounceSquishTimer == 0) { return; }
 
     // If no longer squished, scale back to default.
@@ -1362,6 +1392,7 @@ void squish_mario_model(struct MarioState *m) {
  * Debug function that prints floor normal, velocity, and action information.
  */
 void debug_print_speed_action_normal(struct MarioState *m) {
+    if (!m) { return; }
     f32 steepness;
     f32 floor_nY;
 
@@ -1383,6 +1414,8 @@ void debug_print_speed_action_normal(struct MarioState *m) {
  * Update the button inputs for Mario.
  */
 void update_mario_button_inputs(struct MarioState *m) {
+    if (!m) { return; }
+
     // don't update remote inputs
     if (m->playerIndex != 0) { return; }
 

src/game/mario_actions_airborne.c

@@ -2198,6 +2198,7 @@ s32 check_common_airborne_cancels(struct MarioState *m) {
 }
 
 s32 mario_execute_airborne_action(struct MarioState *m) {
+    if (!m) { return FALSE; }
     u32 cancel;
 
     if (check_common_airborne_cancels(m)) {

src/game/mario_actions_automatic.c

@@ -323,6 +323,7 @@ s32 act_top_of_pole(struct MarioState *m) {
 }
 
 s32 perform_hanging_step(struct MarioState *m, Vec3f nextPos) {
+    if (!m) { return 0; }
     UNUSED s32 unused;
     struct Surface *ceil;
     struct Surface *floor;
@@ -1075,6 +1076,7 @@ s32 check_common_automatic_cancels(struct MarioState *m) {
 }
 
 s32 mario_execute_automatic_action(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel;
 
     if (check_common_automatic_cancels(m)) {

src/game/mario_actions_cutscene.c

@@ -91,6 +91,7 @@ static Vec4s sJumboStarKeyframes[27] = {
  * that's the end of the string.
  */
 s32 get_credits_str_width(char *str) {
+    if (!str) { return 0; }
     u32 c;
     s32 length = 0;
 
@@ -240,6 +241,7 @@ static void stub_is_textbox_active(u16 *a0) {
  * numStars has reached a milestone and prevNumStarsForDialog has not reached it.
  */
 s32 get_star_collection_dialog(struct MarioState *m) {
+    if (!m) { return 0; }
     s32 dialogID = 0;
 
     if (smlua_call_event_hooks_ret_int(HOOK_GET_STAR_COLLECTION_DIALOG, &dialogID)) {
@@ -272,6 +274,8 @@ s32 get_star_collection_dialog(struct MarioState *m) {
 
 // save menu handler
 void handle_save_menu(struct MarioState *m) {
+    if (!m) { return; }
+
     // wait for the menu to show up
     if (is_anim_past_end(m) && gSaveOptSelectIndex != 0) {
         // save and continue / save and quit
@@ -310,6 +314,7 @@ void handle_save_menu(struct MarioState *m) {
  * and yaw plus relative yaw.
  */
 struct Object *spawn_obj_at_mario_rel_yaw(struct MarioState *m, s32 model, const BehaviorScript *behavior, s16 relYaw) {
+    if (!m || !behavior) { return NULL; }
     struct Object *o = spawn_object(m->marioObj, model, behavior);
     if (o == NULL) { return NULL; }
 
@@ -327,6 +332,7 @@ struct Object *spawn_obj_at_mario_rel_yaw(struct MarioState *m, s32 model, const
  * SOUND_ACTION_UNKNOWN43D.
  */
 void cutscene_take_cap_off(struct MarioState *m) {
+    if (!m) { return; }
     m->flags &= ~MARIO_CAP_ON_HEAD;
     m->flags |= MARIO_CAP_IN_HAND;
     play_sound(SOUND_ACTION_UNKNOWN43D, m->marioObj->header.gfx.cameraToObject);
@@ -338,6 +344,7 @@ void cutscene_take_cap_off(struct MarioState *m) {
  * SOUND_ACTION_UNKNOWN43E.
  */
 void cutscene_put_cap_on(struct MarioState *m) {
+    if (!m) { return; }
     m->flags &= ~MARIO_CAP_IN_HAND;
     m->flags |= MARIO_CAP_ON_HEAD;
     play_sound(SOUND_ACTION_UNKNOWN43E, m->marioObj->header.gfx.cameraToObject);
@@ -353,6 +360,7 @@ void cutscene_put_cap_on(struct MarioState *m) {
  * 3: Mario must not be in first person mode.
  */
 s32 mario_ready_to_speak(struct MarioState* m) {
+    if (!m) { return FALSE; }
     u32 actionGroup = m->action & ACT_GROUP_MASK;
     s32 isReadyToSpeak = FALSE;
 
@@ -367,6 +375,7 @@ s32 mario_ready_to_speak(struct MarioState* m) {
 }
 
 u8 should_start_or_continue_dialog(struct MarioState* m, struct Object* object) {
+    if (!m) { return FALSE; }
     if (!m->visibleToEnemies) { return FALSE; }
     if (m->playerIndex == 0) { return TRUE; }
     return (gContinueDialogFunctionObject == object);
@@ -379,6 +388,8 @@ u8 should_start_or_continue_dialog(struct MarioState* m, struct Object* object)
 // 1 = starting dialog
 // 2 = speaking
 s32 set_mario_npc_dialog(struct MarioState* m, s32 actionArg, u8 (*inContinueDialogFunction)(void)) {
+    if (!m) { return 0; }
+
     s32 dialogState = 0;
 
     if (m->playerIndex == 0) {
@@ -424,6 +435,7 @@ s32 set_mario_npc_dialog(struct MarioState* m, s32 actionArg, u8 (*inContinueDia
 // 9 - 22: looking away from npc
 // 23: end
 s32 act_reading_npc_dialog(struct MarioState *m) {
+    if (!m) { return 23; }
     s32 headTurnAmount = 0;
     s16 angleToNPC;
 
@@ -1820,6 +1832,7 @@ s32 act_putting_on_cap(struct MarioState *m) {
 
 void stuck_in_ground_handler(struct MarioState *m, s32 animation, s32 unstuckFrame, s32 target2,
                              s32 target3, s32 endAction) {
+    if (!m) { return; }
     s32 animFrame = set_mario_animation(m, animation);
 
     if (m->input & INPUT_A_PRESSED) {
@@ -2984,6 +2997,8 @@ static s32 check_for_instant_quicksand(struct MarioState *m) {
 }
 
 s32 mario_execute_cutscene_action(struct MarioState *m) {
+    if (!m) { return FALSE; }
+
     s32 cancel;
 
     if (check_for_instant_quicksand(m)) {

src/game/mario_actions_moving.c

@@ -67,12 +67,14 @@ struct LandingAction sBackflipLandAction = {
 Mat4 sFloorAlignMatrix[MAX_PLAYERS];
 
 s16 tilt_body_running(struct MarioState *m) {
+    if (!m) { return 0; }
     s16 pitch = find_floor_slope(m, 0);
     pitch = pitch * m->forwardVel / 40.0f;
     return -pitch;
 }
 
 void play_step_sound(struct MarioState *m, s16 frame1, s16 frame2) {
+    if (!m) { return; }
     if (is_anim_past_frame(m, frame1) || is_anim_past_frame(m, frame2)) {
         if (m->flags & MARIO_METAL_CAP) {
             if (m->marioObj->header.gfx.animInfo.animID == MARIO_ANIM_TIPTOE) {
@@ -91,18 +93,21 @@ void play_step_sound(struct MarioState *m, s16 frame1, s16 frame2) {
 }
 
 void align_with_floor(struct MarioState *m) {
+    if (!m) { return; }
     m->pos[1] = m->floorHeight + get_character_anim_offset(m);
     mtxf_align_terrain_triangle(sFloorAlignMatrix[m->playerIndex], m->pos, m->faceAngle[1], 40.0f);
     m->marioObj->header.gfx.throwMatrix = &sFloorAlignMatrix[m->playerIndex];
 }
 
 s32 begin_walking_action(struct MarioState *m, f32 forwardVel, u32 action, u32 actionArg) {
+    if (!m) { return 0; }
     m->faceAngle[1] = m->intendedYaw;
     mario_set_forward_vel(m, forwardVel);
     return set_mario_action(m, action, actionArg);
 }
 
 void check_ledge_climb_down(struct MarioState *m) {
+    if (!m) { return; }
     struct WallCollisionData wallCols;
     struct Surface *floor;
     f32 floorHeight;
@@ -140,6 +145,7 @@ void check_ledge_climb_down(struct MarioState *m) {
 }
 
 void slide_bonk(struct MarioState *m, u32 fastAction, u32 slowAction) {
+    if (!m) { return; }
     if (m->forwardVel > 16.0f) {
         mario_bonk_reflection(m, TRUE);
         drop_and_set_mario_action(m, fastAction, 0);
@@ -150,6 +156,8 @@ void slide_bonk(struct MarioState *m, u32 fastAction, u32 slowAction) {
 }
 
 s32 set_triple_jump_action(struct MarioState *m, UNUSED u32 action, UNUSED u32 actionArg) {
+    if (!m) { return FALSE; }
+
     if (m->flags & MARIO_WING_CAP) {
         return set_mario_action(m, ACT_FLYING_TRIPLE_JUMP, 0);
     } else if (m->forwardVel > 20.0f || (gServerSettings.enableCheats && gCheats.alwaysTripleJump && m->playerIndex == 0)) {
@@ -162,6 +170,7 @@ s32 set_triple_jump_action(struct MarioState *m, UNUSED u32 action, UNUSED u32 a
 }
 
 void update_sliding_angle(struct MarioState *m, f32 accel, f32 lossFactor) {
+    if (!m) { return; }
     s32 newFacingDYaw;
     s16 facingDYaw;
 
@@ -224,6 +233,7 @@ void update_sliding_angle(struct MarioState *m, f32 accel, f32 lossFactor) {
 }
 
 s32 update_sliding(struct MarioState *m, f32 stopSpeed) {
+    if (!m) { return FALSE; }
     f32 lossFactor;
     f32 accel;
     f32 oldSpeed;
@@ -288,6 +298,7 @@ s32 update_sliding(struct MarioState *m, f32 stopSpeed) {
 }
 
 void apply_slope_accel(struct MarioState *m) {
+    if (!m) { return; }
     f32 slopeAccel;
 
     struct Surface *floor = m->floor;
@@ -340,6 +351,7 @@ void apply_slope_accel(struct MarioState *m) {
 }
 
 s32 apply_landing_accel(struct MarioState *m, f32 frictionFactor) {
+    if (!m) { return FALSE; }
     s32 stopped = FALSE;
 
     apply_slope_accel(m);
@@ -356,6 +368,7 @@ s32 apply_landing_accel(struct MarioState *m, f32 frictionFactor) {
 }
 
 void update_shell_speed(struct MarioState *m) {
+    if (!m) { return; }
     f32 maxTargetSpeed;
     f32 targetSpeed;
 
@@ -399,6 +412,7 @@ void update_shell_speed(struct MarioState *m) {
 }
 
 s32 apply_slope_decel(struct MarioState *m, f32 decelCoef) {
+    if (!m) { return 0; }
     f32 decel;
     s32 stopped = FALSE;
 
@@ -426,6 +440,7 @@ s32 apply_slope_decel(struct MarioState *m, f32 decelCoef) {
 }
 
 s32 update_decelerating_speed(struct MarioState *m) {
+    if (!m) { return 0; }
     s32 stopped = FALSE;
 
     if ((m->forwardVel = approach_f32(m->forwardVel, 0.0f, 1.0f, 1.0f)) == 0.0f) {
@@ -440,6 +455,7 @@ s32 update_decelerating_speed(struct MarioState *m) {
 }
 
 void update_walking_speed(struct MarioState *m) {
+    if (!m) { return; }
     f32 maxTargetSpeed;
     f32 targetSpeed;
 
@@ -477,6 +493,7 @@ void update_walking_speed(struct MarioState *m) {
 }
 
 s32 should_begin_sliding(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->input & INPUT_ABOVE_SLIDE) {
         s32 slideLevel = (m->area->terrainType & TERRAIN_MASK) == TERRAIN_SLIDE;
         s32 movingBackward = m->forwardVel <= -1.0f;
@@ -490,11 +507,13 @@ s32 should_begin_sliding(struct MarioState *m) {
 }
 
 s32 analog_stick_held_back(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s16 intendedDYaw = m->intendedYaw - m->faceAngle[1];
     return intendedDYaw < -0x471C || intendedDYaw > 0x471C;
 }
 
 s32 check_ground_dive_or_punch(struct MarioState *m) {
+    if (!m) { return FALSE; }
     UNUSED s32 unused;
 
     if (m->input & INPUT_B_PRESSED) {
@@ -511,6 +530,7 @@ s32 check_ground_dive_or_punch(struct MarioState *m) {
 }
 
 s32 begin_braking_action(struct MarioState *m) {
+    if (!m) { return FALSE; }
     mario_drop_held_object(m);
 
     if (m->actionState == 1) {
@@ -526,6 +546,7 @@ s32 begin_braking_action(struct MarioState *m) {
 }
 
 void anim_and_audio_for_walk(struct MarioState *m) {
+    if (!m) { return; }
     s32 val14;
     struct Object *marioObj = m->marioObj;
     s32 val0C = TRUE;
@@ -617,6 +638,7 @@ void anim_and_audio_for_walk(struct MarioState *m) {
 }
 
 void anim_and_audio_for_hold_walk(struct MarioState *m) {
+    if (!m) { return; }
     s32 val0C;
     s32 val08 = TRUE;
     f32 val04;
@@ -674,12 +696,14 @@ void anim_and_audio_for_hold_walk(struct MarioState *m) {
 }
 
 void anim_and_audio_for_heavy_walk(struct MarioState *m) {
+    if (!m) { return; }
     s32 val04 = (s32)(m->intendedMag * 0x10000);
     set_mario_anim_with_accel(m, MARIO_ANIM_WALK_WITH_HEAVY_OBJ, val04);
     play_step_sound(m, 26, 79);
 }
 
 void push_or_sidle_wall(struct MarioState *m, Vec3f startPos) {
+    if (!m) { return; }
     s16 wallAngle;
     s16 dWallAngle;
     f32 dx = m->pos[0] - startPos[0];
@@ -721,6 +745,7 @@ void push_or_sidle_wall(struct MarioState *m, Vec3f startPos) {
 }
 
 void tilt_body_walking(struct MarioState *m, s16 startYaw) {
+    if (!m) { return; }
     struct MarioBodyState *val0C = m->marioBodyState;
     UNUSED struct Object *marioObj = m->marioObj;
     s16 animID = m->marioObj->header.gfx.animInfo.animID;
@@ -755,6 +780,7 @@ void tilt_body_walking(struct MarioState *m, s16 startYaw) {
 }
 
 void tilt_body_ground_shell(struct MarioState *m, s16 startYaw) {
+    if (!m) { return; }
     struct MarioBodyState *val0C = m->marioBodyState;
     struct Object *marioObj = m->marioObj;
     s16 dYaw = m->faceAngle[1] - startYaw;
@@ -787,6 +813,7 @@ void tilt_body_ground_shell(struct MarioState *m, s16 startYaw) {
 }
 
 s32 act_walking(struct MarioState *m) {
+    if (!m) { return FALSE; }
     Vec3f startPos;
     s16 startYaw = m->faceAngle[1];
 
@@ -850,6 +877,7 @@ s32 act_walking(struct MarioState *m) {
 }
 
 s32 act_move_punching(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (should_begin_sliding(m)) {
         return set_mario_action(m, ACT_BEGIN_SLIDING, 0);
     }
@@ -885,6 +913,7 @@ s32 act_move_punching(struct MarioState *m) {
 }
 
 s32 act_hold_walking(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->heldObj != NULL && m->heldObj->behavior == segmented_to_virtual(smlua_override_behavior(bhvJumpingBox))) {
         return set_mario_action(m, ACT_CRAZY_BOX_BOUNCE, 0);
     }
@@ -939,6 +968,7 @@ s32 act_hold_walking(struct MarioState *m) {
 }
 
 s32 act_hold_heavy_walking(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->input & INPUT_B_PRESSED) {
         return set_mario_action(m, ACT_HEAVY_THROW, 0);
     }
@@ -972,6 +1002,7 @@ s32 act_hold_heavy_walking(struct MarioState *m) {
 }
 
 s32 act_turning_around(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->input & INPUT_ABOVE_SLIDE) {
         return set_mario_action(m, ACT_BEGIN_SLIDING, 0);
     }
@@ -1023,6 +1054,7 @@ s32 act_turning_around(struct MarioState *m) {
 }
 
 s32 act_finish_turning_around(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->input & INPUT_ABOVE_SLIDE) {
         return set_mario_action(m, ACT_BEGIN_SLIDING, 0);
     }
@@ -1047,6 +1079,7 @@ s32 act_finish_turning_around(struct MarioState *m) {
 }
 
 s32 act_braking(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (!(m->input & INPUT_FIRST_PERSON)
         && (m->input
             & (INPUT_NONZERO_ANALOG | INPUT_A_PRESSED | INPUT_OFF_FLOOR | INPUT_ABOVE_SLIDE))) {
@@ -1082,6 +1115,7 @@ s32 act_braking(struct MarioState *m) {
 }
 
 s32 act_decelerating(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 val0C;
     s16 slopeClass = mario_get_floor_class(m);
 
@@ -1144,6 +1178,7 @@ s32 act_decelerating(struct MarioState *m) {
 }
 
 s32 act_hold_decelerating(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 val0C;
     s16 slopeClass = mario_get_floor_class(m);
 
@@ -1210,6 +1245,7 @@ s32 act_hold_decelerating(struct MarioState *m) {
 }
 
 s32 act_riding_shell_ground(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s16 startYaw = m->faceAngle[1];
 
     if (m->input & INPUT_A_PRESSED) {
@@ -1256,6 +1292,7 @@ s32 act_riding_shell_ground(struct MarioState *m) {
 }
 
 s32 act_crawling(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 val04;
 
     if (should_begin_sliding(m)) {
@@ -1309,6 +1346,7 @@ s32 act_crawling(struct MarioState *m) {
 }
 
 s32 act_burning_ground(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->input & INPUT_A_PRESSED) {
         return set_mario_action(m, ACT_BURNING_JUMP, 0);
     }
@@ -1365,12 +1403,14 @@ s32 act_burning_ground(struct MarioState *m) {
 }
 
 void tilt_body_butt_slide(struct MarioState *m) {
+    if (!m) { return; }
     s16 intendedDYaw = m->intendedYaw - m->faceAngle[1];
     m->marioBodyState->torsoAngle[0] = (s32)(5461.3335f * m->intendedMag / 32.0f * coss(intendedDYaw));
     m->marioBodyState->torsoAngle[2] = (s32)(-(5461.3335f * m->intendedMag / 32.0f * sins(intendedDYaw)));
 }
 
 void common_slide_action(struct MarioState *m, u32 endAction, u32 airAction, s32 animation) {
+    if (!m) { return; }
     Vec3f pos;
 
     vec3f_copy(pos, m->pos);
@@ -1425,6 +1465,7 @@ void common_slide_action(struct MarioState *m, u32 endAction, u32 airAction, s32
 
 s32 common_slide_action_with_jump(struct MarioState *m, u32 stopAction, u32 jumpAction, u32 airAction,
                                   s32 animation) {
+    if (!m) { return FALSE; }
     if (m->actionTimer == 5) {
         if (m->input & INPUT_A_PRESSED) {
             return set_jumping_action(m, jumpAction, 0);
@@ -1442,6 +1483,7 @@ s32 common_slide_action_with_jump(struct MarioState *m, u32 stopAction, u32 jump
 }
 
 s32 act_butt_slide(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel = common_slide_action_with_jump(m, ACT_BUTT_SLIDE_STOP, ACT_JUMP, ACT_BUTT_SLIDE_AIR,
                                                MARIO_ANIM_SLIDE);
     tilt_body_butt_slide(m);
@@ -1449,6 +1491,7 @@ s32 act_butt_slide(struct MarioState *m) {
 }
 
 s32 act_hold_butt_slide(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel;
 
     if (m->marioObj->oInteractStatus & INT_STATUS_MARIO_DROP_OBJECT) {
@@ -1462,6 +1505,7 @@ s32 act_hold_butt_slide(struct MarioState *m) {
 }
 
 s32 act_crouch_slide(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel;
 
     if (m->input & INPUT_ABOVE_SLIDE) {
@@ -1499,6 +1543,7 @@ s32 act_crouch_slide(struct MarioState *m) {
 }
 
 s32 act_slide_kick_slide(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->input & INPUT_A_PRESSED) {
         queue_rumble_data_mario(m, 5, 80);
         return set_jumping_action(m, ACT_FORWARD_ROLLOUT, 0);
@@ -1528,6 +1573,7 @@ s32 act_slide_kick_slide(struct MarioState *m) {
 }
 
 s32 stomach_slide_action(struct MarioState *m, u32 stopAction, u32 airAction, s32 animation) {
+    if (!m) { return FALSE; }
     if (m->actionTimer == 5) {
         if (!(m->input & INPUT_ABOVE_SLIDE) && (m->input & (INPUT_A_PRESSED | INPUT_B_PRESSED))) {
             queue_rumble_data_mario(m, 5, 80);
@@ -1550,11 +1596,13 @@ s32 stomach_slide_action(struct MarioState *m, u32 stopAction, u32 airAction, s3
 }
 
 s32 act_stomach_slide(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel = stomach_slide_action(m, ACT_STOMACH_SLIDE_STOP, ACT_FREEFALL, MARIO_ANIM_SLIDE_DIVE);
     return cancel;
 }
 
 s32 act_hold_stomach_slide(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel;
 
     if (m->marioObj->oInteractStatus & INT_STATUS_MARIO_DROP_OBJECT) {
@@ -1566,6 +1614,7 @@ s32 act_hold_stomach_slide(struct MarioState *m) {
 }
 
 s32 act_dive_slide(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (!(m->input & INPUT_ABOVE_SLIDE) && (m->input & (INPUT_A_PRESSED | INPUT_B_PRESSED))) {
         queue_rumble_data_mario(m, 5, 80);
         return set_mario_action(m, m->forwardVel > 0.0f ? ACT_FORWARD_ROLLOUT : ACT_BACKWARD_ROLLOUT,
@@ -1597,6 +1646,7 @@ s32 act_dive_slide(struct MarioState *m) {
 }
 
 s32 common_ground_knockback_action(struct MarioState *m, s32 animation, s32 arg2, s32 arg3, s32 arg4) {
+    if (!m) { return 0; }
     s32 animFrame;
 
     if (arg3) {
@@ -1656,6 +1706,7 @@ s32 common_ground_knockback_action(struct MarioState *m, s32 animation, s32 arg2
 }
 
 s32 act_hard_backward_ground_kb(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 animFrame =
         common_ground_knockback_action(m, MARIO_ANIM_FALL_OVER_BACKWARDS, 43, TRUE, m->actionArg);
     if (animFrame == 43 && m->health < 0x100) {
@@ -1676,6 +1727,7 @@ s32 act_hard_backward_ground_kb(struct MarioState *m) {
 }
 
 s32 act_hard_forward_ground_kb(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 animFrame =
         common_ground_knockback_action(m, MARIO_ANIM_LAND_ON_STOMACH, 21, TRUE, m->actionArg);
     if (animFrame == 23 && m->health < 0x100) {
@@ -1686,26 +1738,31 @@ s32 act_hard_forward_ground_kb(struct MarioState *m) {
 }
 
 s32 act_backward_ground_kb(struct MarioState *m) {
+    if (!m) { return FALSE; }
     common_ground_knockback_action(m, MARIO_ANIM_BACKWARD_KB, 22, TRUE, m->actionArg);
     return FALSE;
 }
 
 s32 act_forward_ground_kb(struct MarioState *m) {
+    if (!m) { return FALSE; }
     common_ground_knockback_action(m, MARIO_ANIM_FORWARD_KB, 20, TRUE, m->actionArg);
     return FALSE;
 }
 
 s32 act_soft_backward_ground_kb(struct MarioState *m) {
+    if (!m) { return FALSE; }
     common_ground_knockback_action(m, MARIO_ANIM_SOFT_BACK_KB, 100, FALSE, m->actionArg);
     return FALSE;
 }
 
 s32 act_soft_forward_ground_kb(struct MarioState *m) {
+    if (!m) { return FALSE; }
     common_ground_knockback_action(m, MARIO_ANIM_SOFT_FRONT_KB, 100, FALSE, m->actionArg);
     return FALSE;
 }
 
 s32 act_ground_bonk(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 animFrame =
         common_ground_knockback_action(m, MARIO_ANIM_GROUND_BONK, 32, TRUE, m->actionArg);
     if (animFrame == 32) {
@@ -1715,6 +1772,7 @@ s32 act_ground_bonk(struct MarioState *m) {
 }
 
 s32 act_death_exit_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 animFrame;
 
     apply_landing_accel(m, 0.9f);
@@ -1737,6 +1795,7 @@ s32 act_death_exit_land(struct MarioState *m) {
 }
 
 u32 common_landing_action(struct MarioState *m, s16 animation, u32 airAction) {
+    if (!m) { return 0; }
     u32 stepResult;
 
     if (m->input & INPUT_NONZERO_ANALOG) {
@@ -1774,6 +1833,7 @@ u32 common_landing_action(struct MarioState *m, s16 animation, u32 airAction) {
 
 s32 common_landing_cancels(struct MarioState *m, struct LandingAction *landingAction,
                            s32 (*setAPressAction)(struct MarioState *, u32, u32)) {
+    if (!m) { return 0; }
     //! Everything here, including floor steepness, is checked before checking
     // if Mario is actually on the floor. This leads to e.g. remote sliding.
 
@@ -1807,6 +1867,7 @@ s32 common_landing_cancels(struct MarioState *m, struct LandingAction *landingAc
 }
 
 s32 act_jump_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (common_landing_cancels(m, &sJumpLandAction, set_jumping_action)) {
         return TRUE;
     }
@@ -1816,6 +1877,7 @@ s32 act_jump_land(struct MarioState *m) {
 }
 
 s32 act_freefall_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (common_landing_cancels(m, &sFreefallLandAction, set_jumping_action)) {
         return TRUE;
     }
@@ -1825,6 +1887,7 @@ s32 act_freefall_land(struct MarioState *m) {
 }
 
 s32 act_side_flip_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (common_landing_cancels(m, &sSideFlipLandAction, set_jumping_action)) {
         return TRUE;
     }
@@ -1836,6 +1899,7 @@ s32 act_side_flip_land(struct MarioState *m) {
 }
 
 s32 act_hold_jump_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->marioObj->oInteractStatus & INT_STATUS_MARIO_DROP_OBJECT) {
         return drop_and_set_mario_action(m, ACT_JUMP_LAND_STOP, 0);
     }
@@ -1849,6 +1913,7 @@ s32 act_hold_jump_land(struct MarioState *m) {
 }
 
 s32 act_hold_freefall_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->marioObj->oInteractStatus & INT_STATUS_MARIO_DROP_OBJECT) {
         return drop_and_set_mario_action(m, ACT_FREEFALL_LAND_STOP, 0);
     }
@@ -1862,6 +1927,7 @@ s32 act_hold_freefall_land(struct MarioState *m) {
 }
 
 s32 act_long_jump_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
 #ifdef VERSION_SH
     // BLJ (Backwards Long Jump) speed build up fix, crushing SimpleFlips's dreams since July 1997
     if (m->forwardVel < 0.0f) {
@@ -1889,6 +1955,7 @@ s32 act_long_jump_land(struct MarioState *m) {
 }
 
 s32 act_double_jump_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (common_landing_cancels(m, &sDoubleJumpLandAction, set_triple_jump_action)) {
         return TRUE;
     }
@@ -1897,6 +1964,7 @@ s32 act_double_jump_land(struct MarioState *m) {
 }
 
 s32 act_triple_jump_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     m->input &= ~INPUT_A_PRESSED;
 
     if (common_landing_cancels(m, &sTripleJumpLandAction, set_jumping_action)) {
@@ -1912,6 +1980,7 @@ s32 act_triple_jump_land(struct MarioState *m) {
 }
 
 s32 act_backflip_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (!(m->input & INPUT_Z_DOWN)) {
         m->input &= ~INPUT_A_PRESSED;
     }
@@ -1930,6 +1999,7 @@ s32 act_backflip_land(struct MarioState *m) {
 
 s32 quicksand_jump_land_action(struct MarioState *m, s32 animation1, s32 animation2, u32 endAction,
                                u32 airAction) {
+    if (!m) { return FALSE; }
     if (m->actionTimer++ < 6) {
         m->quicksandDepth -= (7 - m->actionTimer) * 0.8f;
         if (m->quicksandDepth < 1.0f) {
@@ -1955,12 +2025,14 @@ s32 quicksand_jump_land_action(struct MarioState *m, s32 animation1, s32 animati
 }
 
 s32 act_quicksand_jump_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel = quicksand_jump_land_action(m, MARIO_ANIM_SINGLE_JUMP, MARIO_ANIM_LAND_FROM_SINGLE_JUMP,
                                             ACT_JUMP_LAND_STOP, ACT_FREEFALL);
     return cancel;
 }
 
 s32 act_hold_quicksand_jump_land(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel = quicksand_jump_land_action(m, MARIO_ANIM_JUMP_WITH_LIGHT_OBJ,
                                             MARIO_ANIM_JUMP_LAND_WITH_LIGHT_OBJ, ACT_HOLD_JUMP_LAND_STOP,
                                             ACT_HOLD_FREEFALL);
@@ -1968,6 +2040,7 @@ s32 act_hold_quicksand_jump_land(struct MarioState *m) {
 }
 
 s32 check_common_moving_cancels(struct MarioState *m) {
+    if (!m) { return FALSE; }
     if (m->pos[1] < m->waterLevel - 100) {
         return set_water_plunge_action(m);
     }
@@ -1990,6 +2063,7 @@ s32 check_common_moving_cancels(struct MarioState *m) {
 }
 
 s32 mario_execute_moving_action(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel;
 
     if (check_common_moving_cancels(m)) {

src/game/mario_actions_object.c

@@ -483,6 +483,7 @@ s32 check_common_object_cancels(struct MarioState *m) {
 }
 
 s32 mario_execute_object_action(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel;
 
     if (check_common_object_cancels(m)) {

src/game/mario_actions_stationary.c

@@ -1127,6 +1127,7 @@ s32 check_common_stationary_cancels(struct MarioState *m) {
 }
 
 s32 mario_execute_stationary_action(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel;
 
     if (check_common_stationary_cancels(m)) {

src/game/mario_actions_submerged.c

@@ -179,6 +179,7 @@ void apply_water_current(struct MarioState *m, Vec3f step) {
 }
 
 u32 perform_water_step(struct MarioState *m) {
+    if (!m) { return 0; }
     UNUSED u32 unused;
     u32 stepResult;
     Vec3f nextPos;
@@ -1588,6 +1589,7 @@ static s32 check_common_submerged_cancels(struct MarioState *m) {
 }
 
 s32 mario_execute_submerged_action(struct MarioState *m) {
+    if (!m) { return FALSE; }
     s32 cancel;
 
     if (check_common_submerged_cancels(m)) {

src/game/mario_step.c

@@ -332,6 +332,7 @@ static s32 perform_ground_quarter_step(struct MarioState *m, Vec3f nextPos) {
 }
 
 s32 perform_ground_step(struct MarioState *m) {
+    if (!m) { return 0; }
     s32 i;
     u32 stepResult;
     Vec3f intendedPos;
@@ -682,6 +683,7 @@ void apply_vertical_wind(struct MarioState *m) {
 }
 
 s32 perform_air_step(struct MarioState *m, u32 stepArg) {
+    if (!m) { return 0; }
     Vec3f intendedPos;
     s32 i;
     s32 quarterStepResult;

src/game/object_helpers.c

@@ -671,8 +671,10 @@ struct Object *spawn_object_at_origin(struct Object *parent, UNUSED s32 unusedAr
     if (obj == NULL) { return NULL; }
 
     obj->parentObj = parent;
-    obj->header.gfx.areaIndex = parent->header.gfx.areaIndex;
+    if (parent) {
-    obj->header.gfx.activeAreaIndex = parent->header.gfx.areaIndex;
+        obj->header.gfx.areaIndex = parent->header.gfx.areaIndex;
+        obj->header.gfx.activeAreaIndex = parent->header.gfx.areaIndex;
+    }
     obj->globalPlayerIndex = 0;
 
     if (model >= MAX_LOADED_GRAPH_NODES) { model = MODEL_ERROR_MODEL; }