Spoof remaining functions

autogen/common.py

@@ -53,8 +53,80 @@ exclude_structs = [
 
 override_types = { "Gfx", "Vtx" }
 
-spoof_functions = [
-    "interact_*"
+spoof_function_returns = [
+    "interact_*",
+    "does_mario_have_normal_cap_on_head",
+    "mario_lose_cap_to_enemy",
+    "mario_check_object_grab",
+    "passes_pvp_interaction_checks",
+    "should_push_or_pull_door",
+    "take_damage_and_knock_back",
+    "is_anim_at_end",
+    "is_anim_past_end",
+    "is_anim_past_frame",
+    "mario_facing_downhill",
+    "mario_floor_is_*",
+    "set_mario_action",
+    "set_jump_from_landing",
+    "set_jumping_action",
+    "drop_and_set_mario_action",
+    "hurt_and_set_mario_action",
+    "check*",
+    "transition_submerged_to_walking",
+    "set_water_plunge_action",
+    "force_idle_state",
+    "lava_boost_on_wall",
+    "should_get_stuck_in_ground",
+    "common_air_*",
+    "mario_execute*",
+    "let_go_of_ledge",
+    "mario_ready_to_speak",
+    "should_start_or_continue_dialog",
+    "begin_walking_action",
+    "set_triple_jump_action",
+    "update_sliding$",
+    "apply_landing_accel",
+    "apply_slope_decel",
+    "update_decelerating_speed",
+    "should_begin_sliding",
+    "analog_stick_held_back",
+    "begin_braking_action",
+    "common_slide_action_with_jump",
+    "stomach_slide_action",
+    "common_ground_knockback_action",
+    "common_landing_action",
+    "mario_update_punch_sequence",
+    "landing_step",
+    "mario_exit_palette_editor",
+    "mario_update_quicksand",
+    "mario_push_off_steep_floor",
+    "mario_update_moving_sand",
+    "mario_update_windy_ground",
+    "anim_spline_poll",
+    "is_player_active",
+    "is_player_in_local_area",
+    "is_nearest_mario_state_to_object",
+    "obj_is_near_to_and_facing_mario",
+    "mario_is_in_air_action",
+    "mario_is_dive_sliding",
+    "obj_is_mario_ground_pounding_platform",
+    "cur_obj_can_mario_activate_textbox*",
+    "is_nearest_player_to_object",
+    "is_point_close_to_object",
+    "obj_return_home_if_safe",
+    "obj_flicker_and_disappear",
+    "obj_check_if_collided_with_object",
+    "obj_has_behavior",
+    "obj_is_hidden",
+    "obj_attack_collided_from_other_object",
+    "obj_has_model_extended",
+    "turn_obj_away_from_steep_floor",
+]
+
+# This is here until I figure out how to automatically check
+# if a function is not implemented
+struct_functions_disallow = [
+    "common_landing_cancels"
 ]
 
 def extract_integer_datatype(c_type):

autogen/convert_functions.py

@@ -1035,7 +1035,7 @@ def build_functions(processed_files):
         for function in processed_file['functions']:
             function['filename'] = processed_file['filename']
             s += build_function(function, processed_file['extern'], False)
-            for func in spoof_functions:
+            for func in spoof_function_returns:
                 if re.match(func, function["identifier"]):
                     s += build_function(function, processed_file['extern'], True)
     return s
@@ -1063,7 +1063,7 @@ def build_binds(processed_files):
 
         for function in processed_file['functions']:
             s += build_bind(function, False)
-            for func in spoof_functions:
+            for func in spoof_function_returns:
                 if re.match(func, function["identifier"]):
                     s += build_bind(function, True)
     return s

autogen/convert_structs.py

@@ -291,12 +291,12 @@ def table_to_string(table):
         s += line + '\n'
     return s, count
 
-def extracted_functions_info(sid, extracted_functions):
+def extracted_functions_info(sid, processed_files):
     for struct_with_methods, method_info in make_struct_methods.items():
         if sid != struct_with_methods:
             continue
 
-        for file in extracted_functions:
+        for file in processed_files:
             for func in file["functions"]:
                 if len(func["params"]) == 0:
                     continue
@@ -308,6 +308,10 @@ def extracted_functions_info(sid, extracted_functions):
                 real_name = func["identifier"]
                 trimmed_name = func["identifier"]
                 description = func["description"]
+
+                if real_name in struct_functions_disallow:
+                    continue
+
                 for remove_text in method_info["remove"]:
                     text_pos = trimmed_name.find(remove_text)
                     if text_pos == -1:
@@ -613,7 +617,7 @@ def build_struct(struct):
         field_table.append(row)
 
     for name, real_name, _ in extracted_functions_info(sid, extracted_functions):
-        for func in spoof_functions:
+        for func in spoof_function_returns:
             if re.match(func, real_name):
                 real_name = real_name + "_SPOOFED"
                 break
@@ -882,7 +886,7 @@ def get_function_signature(function):
                 sig += ', '.join(['%s: %s' % (param_name, param_type) for param_name, param_type in function_params])
                 sig += ')'
                 function_name = line.replace('(', ' ').split()[1]
-                for func in spoof_functions:
+                for func in spoof_function_returns:
                     if re.match(func, function_name):
                         function_return = "boolean"
                 if function_return:

autogen/lua_definitions/structs.lua

@@ -1226,26 +1226,26 @@
 --- @field public drop_held_object fun(m: MarioState) Causes Mario to drop the object he is currently holding. Sets the held object's state accordingly and places it in front of Mario. Useful for releasing carried objects, such as throwing Bob-ombs or setting down crates
 --- @field public throw_held_object fun(m: MarioState) Throws the object Mario is currently holding. The object is placed in front of Mario and given a forward velocity. Useful for attacking enemies with thrown objects, solving puzzles by throwing crates, or interacting with environment items
 --- @field public stop_riding_and_holding fun(m: MarioState) Causes Mario to stop riding any object (like a shell or Hoot) and also drop any held object. Resets related states to ensure Mario is no longer attached to or holding anything. Useful when changing Mario's state after certain actions, transitions, or to prevent exploits
---- @field public does_have_normal_cap_on_head fun(m: MarioState): integer Checks if Mario is currently wearing his normal cap on his head. Returns true if Mario's flag state matches that of having the normal cap equipped on his head, otherwise false. Useful for determining Mario's cap status
+--- @field public does_have_normal_cap_on_head fun(m: MarioState): boolean Checks if Mario is currently wearing his normal cap on his head. Returns true if Mario's flag state matches that of having the normal cap equipped on his head, otherwise false. Useful for determining Mario's cap status
 --- @field public does_have_blown_cap fun(m: MarioState): boolean Checks if Mario has already had a cap blown off of his head in the current level, Returns true if a blown cap can be found for Mario, false if not. Useful to check if a blown cap exists in the level currently.
 --- @field public blow_off_cap fun(m: MarioState, capSpeed: number) Makes Mario blow off his normal cap at a given speed. Removes the normal cap from Mario's head and spawns it as a collectible object in the game world. Useful for simulating events where Mario loses his cap due to enemy attacks or environmental forces
---- @field public lose_cap_to_enemy fun(m: MarioState, arg: integer): integer Makes Mario lose his normal cap to an enemy, such as Klepto or Ukiki. Updates flags so that the cap is no longer on Mario's head. Returns true if Mario was wearing his normal cap, otherwise false. Useful for scenarios where enemies steal Mario's cap
+--- @field public lose_cap_to_enemy fun(m: MarioState, arg: integer): boolean Makes Mario lose his normal cap to an enemy, such as Klepto or Ukiki. Updates flags so that the cap is no longer on Mario's head. Returns true if Mario was wearing his normal cap, otherwise false. Useful for scenarios where enemies steal Mario's cap
 --- @field public retrieve_cap fun(m: MarioState) Retrieves Mario's normal cap if it was previously lost. Removes the cap from Mario's hand state and places it on his head. Useful when Mario recovers his normal cap from enemies, finds it in a level, or if it were to disappear
 --- @field public get_collided_object fun(m: MarioState, interactType: integer): Object Returns a collided object that matches a given interaction type from Mario's current collision data. Useful for determining which object Mario has come into contact with
---- @field public check_object_grab fun(m: MarioState): integer Checks if Mario can grab the currently encountered object (usually triggered when Mario punches or dives). If conditions are met, initiates the grabbing process. Useful for picking up objects, throwing enemies, or grabbing special items
---- @field public passes_pvp_interaction_checks fun(attacker: MarioState, victim: MarioState): integer Checks if the necessary conditions are met for one player to successfully attack another player in a PvP scenario. Considers factors like invincibility, action states, and whether the attack is valid. Useful for multiplayer where players can harm each other
---- @field public should_push_or_pull_door fun(m: MarioState, o: Object): integer Determines whether Mario should push or pull a door when he interacts with it, based on his orientation and position. Useful for animating door interactions realistically, depending on which side Mario approaches from
---- @field public take_damage_and_knock_back fun(m: MarioState, o: Object): integer Handles the logic of Mario taking damage and being knocked back by a damaging object. Decreases Mario's health, sets his knockback state, and triggers appropriate sound and camera effects. Useful for implementing enemy attacks, hazards, and ensuring Mario receives proper feedback upon taking damage
+--- @field public check_object_grab fun(m: MarioState): boolean Checks if Mario can grab the currently encountered object (usually triggered when Mario punches or dives). If conditions are met, initiates the grabbing process. Useful for picking up objects, throwing enemies, or grabbing special items
+--- @field public passes_pvp_interaction_checks fun(attacker: MarioState, victim: MarioState): boolean Checks if the necessary conditions are met for one player to successfully attack another player in a PvP scenario. Considers factors like invincibility, action states, and whether the attack is valid. Useful for multiplayer where players can harm each other
+--- @field public should_push_or_pull_door fun(m: MarioState, o: Object): boolean Determines whether Mario should push or pull a door when he interacts with it, based on his orientation and position. Useful for animating door interactions realistically, depending on which side Mario approaches from
+--- @field public take_damage_and_knock_back fun(m: MarioState, o: Object): boolean Handles the logic of Mario taking damage and being knocked back by a damaging object. Decreases Mario's health, sets his knockback state, and triggers appropriate sound and camera effects. Useful for implementing enemy attacks, hazards, and ensuring Mario receives proper feedback upon taking damage
 --- @field public determine_interaction fun(m: MarioState, o: Object): integer Determines how Mario interacts with a given object based on his current action, position, and other state variables. Calculates the appropriate interaction type (e.g., punch, kick, ground pound) that should result from Mario's contact with the specified object (`o`). Useful for handling different types of player-object collisions, attacks, and object behaviors
 --- @field public level_trigger_warp fun(m: MarioState, warpOp: integer): integer Triggers a warp (WARP_OP_*) for the level. Pass in `gMarioStates[0]` for `m`
---- @field public is_anim_at_end fun(m: MarioState): integer Checks if Mario's current animation has reached its final frame (i.e., the last valid frame in the animation). Useful for deciding when to transition out of an animation-driven action
---- @field public is_anim_past_end fun(m: MarioState): integer Checks if Mario's current animation has passed the second-to-last valid frame (i.e., effectively at or beyond its final frames). Useful for advanced checks where slightly early transitions or timing are needed before the final frame
+--- @field public is_anim_at_end fun(m: MarioState): boolean Checks if Mario's current animation has reached its final frame (i.e., the last valid frame in the animation). Useful for deciding when to transition out of an animation-driven action
+--- @field public is_anim_past_end fun(m: MarioState): boolean Checks if Mario's current animation has passed the second-to-last valid frame (i.e., effectively at or beyond its final frames). Useful for advanced checks where slightly early transitions or timing are needed before the final frame
 --- @field public set_animation fun(m: MarioState, targetAnimID: integer): integer Sets Mario's current animation to `targetAnimID` at a default acceleration (no speed change)
 --- @field public set_anim_with_accel fun(m: MarioState, targetAnimID: integer, accel: integer): integer Sets Mario's current animation to `targetAnimID` with a custom `accel` value to speed up or slow down the animation. Useful for controlling animation timing, e.g., slow-motion or fast-forward effects
 --- @field public set_character_animation fun(m: MarioState, targetAnimID: CharacterAnimID): integer Sets the character-specific animation at its default rate (no acceleration)
 --- @field public set_character_anim_with_accel fun(m: MarioState, targetAnimID: CharacterAnimID, accel: integer): integer Sets a character-specific animation where the animation speed is adjusted by `accel`. Useful for varying animation speeds based on context or dynamic conditions (e.g., slow-motion)
 --- @field public set_anim_to_frame fun(m: MarioState, animFrame: integer) Sets the current animation frame to a specific `animFrame`
---- @field public is_anim_past_frame fun(m: MarioState, animFrame: integer): integer Checks if Mario's current animation is past a specified `animFrame`. Useful for conditional logic where an action can branch after reaching a specific point in the animation
+--- @field public is_anim_past_frame fun(m: MarioState, animFrame: integer): boolean Checks if Mario's current animation is past a specified `animFrame`. Useful for conditional logic where an action can branch after reaching a specific point in the animation
 --- @field public update_pos_for_anim fun(m: MarioState) Applies the translation from Mario's current animation to his world position. Considers animation flags (horizontal/vertical translation)
 --- @field public return_anim_y_translation fun(m: MarioState): integer Determines the vertical translation from Mario's animation (how much the animation moves Mario up or down). Returns the y-component of the animation's translation. Useful for adjusting Mario's vertical position based on an ongoing animation (e.g., a bounce or jump)
 --- @field public play_sound_if_no_flag fun(m: MarioState, soundBits: integer, flags: integer) Plays a sound if Mario does not currently have a specific flag set. Once played, the flag is set to prevent immediate repeats
@@ -1265,91 +1265,91 @@
 --- @field public set_forward_vel fun(m: MarioState, speed: number) Sets Mario's forward velocity (`m.forwardVel`) and updates `slideVelX/Z` and `m.vel` accordingly, based on `m.faceAngle.y`. Useful for controlling Mario's speed and direction in various actions (jumping, walking, sliding, etc.)
 --- @field public get_floor_class fun(m: MarioState): integer Retrieves the slipperiness class of Mario's current floor, ranging from not slippery to very slippery. Considers terrain types and special surfaces. Useful for controlling friction, movement speed adjustments, and whether Mario slips or walks
 --- @field public get_terrain_sound_addend fun(m: MarioState): integer Computes a value added to terrain sounds, depending on the floor's type (sand, snow, water, etc.) and slipperiness. This returns a sound 'addend' used with sound effects. Useful for playing context-specific footstep or movement sounds
---- @field public facing_downhill fun(m: MarioState, turnYaw: integer): integer Determines if Mario is facing downhill relative to his floor angle, optionally accounting for forward velocity direction. Returns true if he is oriented down the slope. Useful for deciding if Mario will walk or slide on sloped floors
---- @field public floor_is_slippery fun(m: MarioState): integer Checks whether Mario's current floor is slippery based on both the floor's surface class and Mario's environment (e.g., special slides). Useful for deciding if Mario should transition to sliding or maintain normal traction
---- @field public floor_is_slope fun(m: MarioState): integer Checks whether Mario's floor is a slope, i.e., not flat but not necessarily steep. This depends on the floor's surface class and angle
---- @field public floor_is_steep fun(m: MarioState): integer Checks whether Mario's floor is steep enough to cause special behavior, such as forcing slides or preventing certain actions. Returns true if the slope is too steep. Useful for restricting normal movement on surfaces with extreme angles
+--- @field public facing_downhill fun(m: MarioState, turnYaw: integer): boolean Determines if Mario is facing downhill relative to his floor angle, optionally accounting for forward velocity direction. Returns true if he is oriented down the slope. Useful for deciding if Mario will walk or slide on sloped floors
+--- @field public floor_is_slippery fun(m: MarioState): boolean Checks whether Mario's current floor is slippery based on both the floor's surface class and Mario's environment (e.g., special slides). Useful for deciding if Mario should transition to sliding or maintain normal traction
+--- @field public floor_is_slope fun(m: MarioState): boolean Checks whether Mario's floor is a slope, i.e., not flat but not necessarily steep. This depends on the floor's surface class and angle
+--- @field public floor_is_steep fun(m: MarioState): boolean Checks whether Mario's floor is steep enough to cause special behavior, such as forcing slides or preventing certain actions. Returns true if the slope is too steep. Useful for restricting normal movement on surfaces with extreme angles
 --- @field public find_floor_height_relative_polar fun(m: MarioState, angleFromMario: integer, distFromMario: number): number Finds the floor height relative to Mario's current position given a polar displacement (`angleFromMario`, `distFromMario`). Useful for determining height differentials ahead or behind Mario, e.g. for slope checks or collision logic
 --- @field public find_floor_slope fun(m: MarioState, yawOffset: integer): integer Returns a slope angle based on comparing the floor heights slightly in front and behind Mario. It essentially calculates how steep the ground is in a specific yaw direction. Useful for slope-based calculations such as setting walking or sliding behaviors
 --- @field public update_sound_and_camera fun(m: MarioState) Updates the background noise and camera modes based on Mario's action. Especially relevant for actions like first-person view or sleeping. Useful for synchronizing camera behavior and ambient sounds with Mario's state changes
 --- @field public set_steep_jump_action fun(m: MarioState) Transitions Mario into ACT_STEEP_JUMP if the floor is too steep, adjusting his forward velocity and orientation accordingly. Useful for forcing special jump states on surfaces exceeding normal slope limits
 --- @field public set_y_vel_based_on_fspeed fun(m: MarioState, initialVelY: number, multiplier: number) Adjusts Mario's vertical velocity (`m.vel.y`) based on his forward speed. This function also accounts for conditions like quicksand to halve velocity
---- @field public set_action fun(m: MarioState, action: integer, actionArg: integer): integer Sets Mario's action to the specified `action` and `actionArg`, routing through group-specific transition functions (e.g., airborne actions). Resets sound flags and updates internal timers
---- @field public set_jump_from_landing fun(m: MarioState): integer When Mario lands on the ground, decides whether to jump again (single, double, triple) or enter a steep jump if the floor is very steep. Handles quicksand logic as well
---- @field public set_jumping_action fun(m: MarioState, action: integer, actionArg: integer): integer Sets Mario to a jumping action (regular, double, triple, or steep jump) if conditions allow it. If the floor is too steep or if in quicksand, it changes the action accordingly
---- @field public drop_and_set_action fun(m: MarioState, action: integer, actionArg: integer): integer Drops any currently held object and sets Mario to a new action. This function is typically used when Mario transitions to states where he cannot hold objects
---- @field public hurt_and_set_action fun(m: MarioState, action: integer, actionArg: integer, hurtCounter: integer): integer Increments Mario's `hurtCounter` and immediately sets a new action. Often used when Mario takes damage and transitions into a knockback or stunned action.
---- @field public check_common_action_exits fun(m: MarioState): integer Checks for inputs that cause common action transitions (jump, freefall, walking, sliding). Useful for quickly exiting certain stationary actions when Mario begins moving or leaves the floor
---- @field public check_common_hold_action_exits fun(m: MarioState): integer Checks for inputs that cause common hold-action transitions (hold jump, hold freefall, hold walking, hold sliding)
---- @field public transition_submerged_to_walking fun(m: MarioState): integer Transitions Mario from being underwater to a walking state. Resets camera to the default mode and can handle object-holding states. Useful for restoring standard ground movement when emerging from water
---- @field public set_water_plunge_action fun(m: MarioState): integer Transitions Mario into a "water plunge" action, used when he enters water from above. Adjusts position, velocity, and camera mode
---- @field public force_idle_state fun(m: MarioState): integer Forces Mario into an idle state, either `ACT_IDLE` or `ACT_WATER_IDLE` depending on whether he is submerged. Useful for quickly resetting Mario's state to an idle pose under special conditions (e.g., cutscene triggers)
+--- @field public set_action fun(m: MarioState, action: integer, actionArg: integer): boolean Sets Mario's action to the specified `action` and `actionArg`, routing through group-specific transition functions (e.g., airborne actions). Resets sound flags and updates internal timers
+--- @field public set_jump_from_landing fun(m: MarioState): boolean When Mario lands on the ground, decides whether to jump again (single, double, triple) or enter a steep jump if the floor is very steep. Handles quicksand logic as well
+--- @field public set_jumping_action fun(m: MarioState, action: integer, actionArg: integer): boolean Sets Mario to a jumping action (regular, double, triple, or steep jump) if conditions allow it. If the floor is too steep or if in quicksand, it changes the action accordingly
+--- @field public drop_and_set_action fun(m: MarioState, action: integer, actionArg: integer): boolean Drops any currently held object and sets Mario to a new action. This function is typically used when Mario transitions to states where he cannot hold objects
+--- @field public hurt_and_set_action fun(m: MarioState, action: integer, actionArg: integer, hurtCounter: integer): boolean Increments Mario's `hurtCounter` and immediately sets a new action. Often used when Mario takes damage and transitions into a knockback or stunned action.
+--- @field public check_common_action_exits fun(m: MarioState): boolean Checks for inputs that cause common action transitions (jump, freefall, walking, sliding). Useful for quickly exiting certain stationary actions when Mario begins moving or leaves the floor
+--- @field public check_common_hold_action_exits fun(m: MarioState): boolean Checks for inputs that cause common hold-action transitions (hold jump, hold freefall, hold walking, hold sliding)
+--- @field public transition_submerged_to_walking fun(m: MarioState): boolean Transitions Mario from being underwater to a walking state. Resets camera to the default mode and can handle object-holding states. Useful for restoring standard ground movement when emerging from water
+--- @field public set_water_plunge_action fun(m: MarioState): boolean Transitions Mario into a "water plunge" action, used when he enters water from above. Adjusts position, velocity, and camera mode
+--- @field public force_idle_state fun(m: MarioState): boolean Forces Mario into an idle state, either `ACT_IDLE` or `ACT_WATER_IDLE` depending on whether he is submerged. Useful for quickly resetting Mario's state to an idle pose under special conditions (e.g., cutscene triggers)
 --- @field public init_single fun(m: MarioState) Initializes the fields of a single `MarioState` structure when the player spawns or respawns. Sets starting position, velocity, action, and various internal flags
 --- @field public set_particle_flags fun(m: MarioState, flags: integer, clear: integer) Sets Mario's particle flags to spawn various visual effects (dust, water splashes, etc.), with an option to clear or set new flags
 --- @field public update_wall fun(m: MarioState, wcd: WallCollisionData) Updates Mario's wall information based on wall collisions (`WallCollisionData`). Chooses the most relevant wall depending on the level's collision fix settings
 --- @field public play_flip_sounds fun(m: MarioState, frame1: integer, frame2: integer, frame3: integer) Plays a spinning sound at specific animation frames for flips (usually side flips or certain jump flips). If the current animation frame matches any of the specified frames, it triggers `SOUND_ACTION_SPIN`
 --- @field public play_far_fall_sound fun(m: MarioState) Plays a unique sound when Mario has fallen a significant distance without being invulnerable, twirling, or flying. If the fall exceeds a threshold, triggers a "long fall" exclamation. Also sets a flag to prevent repeated triggering
 --- @field public play_knockback_sound fun(m: MarioState) Plays a knockback sound effect if Mario is hit or knocked back with significant velocity. The specific sound differs depending on whether Mario's forward velocity is high enough to be considered a strong knockback
---- @field public lava_boost_on_wall fun(m: MarioState): integer Allows Mario to 'lava boost' off a lava wall, reorienting him to face away from the wall and adjusting forward velocity. Increases Mario's hurt counter if he's not metal, plays a burning sound, and transitions his action to `ACT_LAVA_BOOST`. Useful for handling collisions with lava walls, giving Mario a strong upward/forward boost at the cost of health
---- @field public check_fall_damage fun(m: MarioState, hardFallAction: integer): integer Evaluates whether Mario should take fall damage based on the height difference between his peak and current position. If the fall is large enough and does not occur over burning surfaces or while twirling, Mario may get hurt or enter a hard fall action. If the fall is significant but not extreme, minimal damage and a squish effect may be applied. Useful for determining if Mario's fall warrants a health penalty or a special landing action
---- @field public check_kick_or_dive_in_air fun(m: MarioState): integer Checks if Mario should perform a kick or a dive while in mid-air, depending on his current forward velocity. Pressing the B button in the air can trigger a jump kick (at lower speeds) or a dive (at higher speeds)
---- @field public should_get_stuck_in_ground fun(m: MarioState): integer Determines whether Mario should become stuck in the ground after landing, specifically for soft terrain such as snow or sand, provided certain conditions are met (height of the fall, normal of the floor, etc.). Returns true if Mario should be stuck, false otherwise
---- @field public check_fall_damage_or_get_stuck fun(m: MarioState, hardFallAction: integer): integer Checks if Mario should get stuck in the ground after a large fall onto soft terrain (like snow or sand) or if he should just proceed with regular fall damage calculations. If the terrain and height conditions are met, Mario's action changes to being stuck in the ground. Otherwise, normal fall damage logic applies
---- @field public check_horizontal_wind fun(m: MarioState): integer Checks for the presence of a horizontal wind surface under Mario. If found, applies a push force to Mario's horizontal velocity. Caps speed at certain thresholds, updates Mario's forward velocity and yaw for sliding/wind movement
+--- @field public lava_boost_on_wall fun(m: MarioState): boolean Allows Mario to 'lava boost' off a lava wall, reorienting him to face away from the wall and adjusting forward velocity. Increases Mario's hurt counter if he's not metal, plays a burning sound, and transitions his action to `ACT_LAVA_BOOST`. Useful for handling collisions with lava walls, giving Mario a strong upward/forward boost at the cost of health
+--- @field public check_fall_damage fun(m: MarioState, hardFallAction: integer): boolean Evaluates whether Mario should take fall damage based on the height difference between his peak and current position. If the fall is large enough and does not occur over burning surfaces or while twirling, Mario may get hurt or enter a hard fall action. If the fall is significant but not extreme, minimal damage and a squish effect may be applied. Useful for determining if Mario's fall warrants a health penalty or a special landing action
+--- @field public check_kick_or_dive_in_air fun(m: MarioState): boolean Checks if Mario should perform a kick or a dive while in mid-air, depending on his current forward velocity. Pressing the B button in the air can trigger a jump kick (at lower speeds) or a dive (at higher speeds)
+--- @field public should_get_stuck_in_ground fun(m: MarioState): boolean Determines whether Mario should become stuck in the ground after landing, specifically for soft terrain such as snow or sand, provided certain conditions are met (height of the fall, normal of the floor, etc.). Returns true if Mario should be stuck, false otherwise
+--- @field public check_fall_damage_or_get_stuck fun(m: MarioState, hardFallAction: integer): boolean Checks if Mario should get stuck in the ground after a large fall onto soft terrain (like snow or sand) or if he should just proceed with regular fall damage calculations. If the terrain and height conditions are met, Mario's action changes to being stuck in the ground. Otherwise, normal fall damage logic applies
+--- @field public check_horizontal_wind fun(m: MarioState): boolean Checks for the presence of a horizontal wind surface under Mario. If found, applies a push force to Mario's horizontal velocity. Caps speed at certain thresholds, updates Mario's forward velocity and yaw for sliding/wind movement
 --- @field public update_air_with_turn fun(m: MarioState) Updates Mario's air movement while allowing him to turn. Checks horizontal wind and applies a moderate amount of drag, approaches the forward velocity toward zero if no input is pressed, and modifies forward velocity/angle based on stick input
 --- @field public update_air_without_turn fun(m: MarioState) Updates Mario's air movement without directly turning his facing angle to match his intended yaw. Instead, Mario can move sideways relative to his current facing direction. Also checks horizontal wind and applies drag
 --- @field public update_lava_boost_or_twirling fun(m: MarioState) Updates Mario's movement when in actions like lava boost or twirling in mid-air. Applies player input to adjust forward velocity and facing angle, but in a more restricted manner compared to standard jump movement. Used by `ACT_LAVA_BOOST` and `ACT_TWIRLING`
 --- @field public update_flying_yaw fun(m: MarioState) Calculates and applies a change in Mario's yaw while flying, based on horizontal stick input. Approaches a target yaw velocity and sets Mario's roll angle to simulate banking turns. This results in a more natural, curved flight path
 --- @field public update_flying_pitch fun(m: MarioState) Calculates and applies a change in Mario's pitch while flying, based on vertical stick input. Approaches a target pitch velocity and clamps the final pitch angle to a certain range, simulating a smooth flight control
 --- @field public update_flying fun(m: MarioState) Handles the complete flying logic for Mario (usually with the wing cap). Continuously updates pitch and yaw based on controller input, applies drag, and adjusts forward velocity. Also updates Mario's model angles for flight animations
---- @field public common_air_action_step fun(m: MarioState, landAction: integer, animation: integer, stepArg: integer): integer Performs a standard step update for air actions without knockback, typically used for jumps or freefalls. Updates Mario's velocity (and possibly checks horizontal wind), then calls `perform_air_step` with given `stepArg`. Handles how Mario lands, hits walls, grabs ledges, or grabs ceilings. Optionally sets an animation
---- @field public common_air_knockback_step fun(m: MarioState, landAction: integer, hardFallAction: integer, animation: integer, speed: number): integer A shared step update used for airborne knockback states (both forward and backward). Updates velocity, calls `perform_air_step`, and handles wall collisions or landing transitions to appropriate ground knockback actions. Also sets animation and speed
---- @field public check_wall_kick fun(m: MarioState): integer Checks if Mario should wall kick after performing an air hit against a wall. If the input conditions (e.g., pressing A) and the `wallKickTimer` allow, Mario transitions to `ACT_WALL_KICK_AIR`
---- @field public check_common_airborne_cancels fun(m: MarioState): integer Checks for and handles common conditions that would cancel Mario's current air action. This includes transitioning to a water plunge if below the water level, becoming squished if appropriate, or switching to vertical wind action if on certain wind surfaces. Also resets `m.quicksandDepth`
---- @field public execute_airborne_action fun(m: MarioState): integer Executes Mario's current airborne action by first checking common airborne cancels, then playing a far-fall sound if needed. Dispatches to the appropriate action function, such as jump, double jump, freefall, etc
+--- @field public common_air_action_step fun(m: MarioState, landAction: integer, animation: integer, stepArg: integer): boolean Performs a standard step update for air actions without knockback, typically used for jumps or freefalls. Updates Mario's velocity (and possibly checks horizontal wind), then calls `perform_air_step` with given `stepArg`. Handles how Mario lands, hits walls, grabs ledges, or grabs ceilings. Optionally sets an animation
+--- @field public common_air_knockback_step fun(m: MarioState, landAction: integer, hardFallAction: integer, animation: integer, speed: number): boolean A shared step update used for airborne knockback states (both forward and backward). Updates velocity, calls `perform_air_step`, and handles wall collisions or landing transitions to appropriate ground knockback actions. Also sets animation and speed
+--- @field public check_wall_kick fun(m: MarioState): boolean Checks if Mario should wall kick after performing an air hit against a wall. If the input conditions (e.g., pressing A) and the `wallKickTimer` allow, Mario transitions to `ACT_WALL_KICK_AIR`
+--- @field public check_common_airborne_cancels fun(m: MarioState): boolean Checks for and handles common conditions that would cancel Mario's current air action. This includes transitioning to a water plunge if below the water level, becoming squished if appropriate, or switching to vertical wind action if on certain wind surfaces. Also resets `m.quicksandDepth`
+--- @field public execute_airborne_action fun(m: MarioState): boolean Executes Mario's current airborne action by first checking common airborne cancels, then playing a far-fall sound if needed. Dispatches to the appropriate action function, such as jump, double jump, freefall, etc
 --- @field public add_tree_leaf_particles fun(m: MarioState) Spawns leaf particles when Mario climbs a tree, if he is sufficiently high above the floor. In Shifting Sand Land, the leaf effect spawns higher due to the taller palm trees
 --- @field public play_climbing_sounds fun(m: MarioState, b: integer) Plays the appropriate climbing sound effect depending on whether Mario is on a tree or a pole. If `b == 1`, it plays the "climbing up" sound; otherwise, it plays the "sliding down" sound
 --- @field public set_pole_position fun(m: MarioState, offsetY: number): integer Sets Mario's position and alignment while he is on a climbable pole or tree. This function checks collisions with floors and ceilings, and updates Mario's action if he leaves the pole or touches the floor. Useful for ensuring Mario's correct placement and transitions when climbing poles or trees
 --- @field public perform_hanging_step fun(m: MarioState, nextPos: Vec3f): integer Performs a single step of movement while Mario is hanging from a ceiling. It handles wall collisions and checks the floor and ceiling to determine if Mario remains hanging, leaves the ceiling, or hits it
 --- @field public update_hang_moving fun(m: MarioState): integer Updates Mario's velocity and position while he is moving across a hangable ceiling. It calls `perform_hanging_step()` to handle collisions and movement logic, returning a status code indicating if Mario is still hanging or if he left the ceiling
 --- @field public update_hang_stationary fun(m: MarioState) Keeps Mario stationary while he is hanging from a ceiling. This function zeroes out his velocity and ensures he remains aligned with the ceiling
---- @field public let_go_of_ledge fun(m: MarioState): integer Handles Mario letting go of a ledge by adjusting his position and setting his velocity to make him fall away from the ledge. The action then transitions to a 'soft bonk' state
+--- @field public let_go_of_ledge fun(m: MarioState): boolean Handles Mario letting go of a ledge by adjusting his position and setting his velocity to make him fall away from the ledge. The action then transitions to a 'soft bonk' state
 --- @field public climb_up_ledge fun(m: MarioState) Moves Mario onto the top of a ledge once he finishes climbing it. This shifts Mario forward slightly on the ledge and updates his animation accordingly
 --- @field public update_ledge_climb_camera fun(m: MarioState) Gradually adjusts the camera position to track Mario as he climbs a ledge. This creates a smoother view transition from the ledge-grab camera angle to Mario's new location on top of the ledge
 --- @field public update_ledge_climb fun(m: MarioState, animation: integer, endAction: integer) Updates Mario's climb onto a ledge by setting the chosen climbing animation and transitioning to the specified end action (e.g., standing idle) once the animation finishes. If the end action is `ACT_IDLE`, Mario is placed on top of the ledge
 --- @field public pop_bubble fun(m: MarioState) Makes Mario act like he was popped from a bubble. Useful for custom bubble popping behaviors.
---- @field public check_common_automatic_cancels fun(m: MarioState): integer Checks if Mario should cancel his current automatic action, primarily by detecting if he falls into deep water. If so, transitions him to the water-plunge state
---- @field public execute_automatic_action fun(m: MarioState): integer Executes Mario's current automatic action (e.g., climbing a pole, hanging, ledge-grabbing) by calling the corresponding function. It also checks for common cancellations, like falling into water. Returns true if the action was canceled and a new action was set, or false otherwise
+--- @field public check_common_automatic_cancels fun(m: MarioState): boolean Checks if Mario should cancel his current automatic action, primarily by detecting if he falls into deep water. If so, transitions him to the water-plunge state
+--- @field public execute_automatic_action fun(m: MarioState): boolean Executes Mario's current automatic action (e.g., climbing a pole, hanging, ledge-grabbing) by calling the corresponding function. It also checks for common cancellations, like falling into water. Returns true if the action was canceled and a new action was set, or false otherwise
 --- @field public get_star_collection_dialog fun(m: MarioState): integer Determines which (if any) dialog to show when Mario collects a star. Checks milestone star counts against `prevNumStarsForDialog`, and returns a dialog ID if a milestone is reached. Otherwise, returns 0
 --- @field public handle_save_menu fun(m: MarioState) Handles interactions with the save menu after collecting a star/key. Checks the user's selection (e.g., Save and Continue) and performs the corresponding action, such as saving the file or returning Mario to idle
 --- @field public cutscene_take_cap_off fun(m: MarioState) Transitions Mario's state from wearing the cap on his head to holding it in his hand. Clears the `MARIO_CAP_ON_HEAD` flag, sets the `MARIO_CAP_IN_HAND` flag, and plays the 'take cap off' sound
 --- @field public cutscene_put_cap_on fun(m: MarioState) Transitions Mario's state from having the cap in his hand to wearing it on his head. Clears the `MARIO_CAP_IN_HAND` flag, sets the `MARIO_CAP_ON_HEAD` flag, and plays the 'put cap on' sound
---- @field public ready_to_speak fun(m: MarioState): integer Checks if Mario's current action allows him to speak. For Mario to be ready, his action must be in a 'stationary' or 'moving' group (or waiting for dialog), and he must not be riding a shell, invulnerable, or in first-person mode
---- @field public should_start_or_continue_dialog fun(m: MarioState, object: Object): integer Checks if the dialog from a specified `object` should start or continue for this particular Mario. Ensures Mario is visible to enemies (i.e., not in certain invulnerable states) and, for remote players, validates the correct dialog object
+--- @field public ready_to_speak fun(m: MarioState): boolean Checks if Mario's current action allows him to speak. For Mario to be ready, his action must be in a 'stationary' or 'moving' group (or waiting for dialog), and he must not be riding a shell, invulnerable, or in first-person mode
+--- @field public should_start_or_continue_dialog fun(m: MarioState, object: Object): boolean Checks if the dialog from a specified `object` should start or continue for this particular Mario. Ensures Mario is visible to enemies (i.e., not in certain invulnerable states) and, for remote players, validates the correct dialog object
 --- @field public general_star_dance_handler fun(m: MarioState, isInWater: integer) Manages the star collection dance sequence for Mario, both on land and in water. Plays music, spawns the celebration star, increments the star count, and triggers level exits or dialogs at the correct times
 --- @field public common_death_handler fun(m: MarioState, animation: integer, frameToDeathWarp: integer): integer Handles shared logic for Mario's various death states. Plays the specified death animation (`animation`), checks for a specific frame (`frameToDeathWarp`) to trigger a warp or bubble state if allowed, and sets Mario's eye state to 'dead'
 --- @field public launch_until_land fun(m: MarioState, endAction: integer, animation: integer, forwardVel: number): integer Launches Mario forward with a given velocity (`forwardVel`) and sets his animation. Continues moving him through the air until he lands, then changes Mario's action to `endAction`
 --- @field public stuck_in_ground_handler fun(m: MarioState, animation: integer, unstuckFrame: integer, target2: integer, target3: integer, endAction: integer) Handles the cutscene and animation sequence for when Mario is stuck in the ground (head, butt, or feet). Plays a designated `animation`, checks specific frames (`unstuckFrame`, `target2`, `target3`) for sound effects or transitions, and frees Mario to the `endAction` once the animation completes
---- @field public execute_cutscene_action fun(m: MarioState): integer Executes Mario's current cutscene action based on his `action` field. Includes various story-related sequences like entering doors, collecting stars, and final boss cutscenes. Delegates to the appropriate function for each cutscene action
+--- @field public execute_cutscene_action fun(m: MarioState): boolean Executes Mario's current cutscene action based on his `action` field. Includes various story-related sequences like entering doors, collecting stars, and final boss cutscenes. Delegates to the appropriate function for each cutscene action
 --- @field public tilt_body_running fun(m: MarioState): integer Tilts Mario's body according to his running speed and slope angle. Calculates a pitch offset used while running to simulate leaning forward at higher speeds or on slopes
 --- @field public play_step_sound fun(m: MarioState, frame1: integer, frame2: integer) Checks the current animation frame against two specified frames to trigger footstep sounds. Also chooses specific sounds if Mario is wearing Metal Cap or is in quicksand
 --- @field public align_with_floor fun(m: MarioState) Aligns Mario's position and model transformation matrix to match the floor's angle. Specifically: Sets Mario's vertical position to be at `m.floorHeight` plus any active character animation offset and adjusts Mario's `throwMatrix` so that his body appears flush with the floor
---- @field public begin_walking_action fun(m: MarioState, forwardVel: number, action: integer, actionArg: integer): integer Sets Mario's facing yaw to his intended yaw, applies a specified forward velocity, and transitions to the given action (e.g., `ACT_WALKING`).
---- @field public check_ledge_climb_down fun(m: MarioState) Checks if Mario is near an edge while moving slowly and the floor below that edge is significantly lower. If the conditions are met, transitions Mario into a ledge-climb-down action and positions him accordingly on the edge
+--- @field public begin_walking_action fun(m: MarioState, forwardVel: number, action: integer, actionArg: integer): boolean Sets Mario's facing yaw to his intended yaw, applies a specified forward velocity, and transitions to the given action (e.g., `ACT_WALKING`).
+--- @field public check_ledge_climb_down fun(m: MarioState): boolean Checks if Mario is near an edge while moving slowly and the floor below that edge is significantly lower. If the conditions are met, transitions Mario into a ledge-climb-down action and positions him accordingly on the edge
 --- @field public slide_bonk fun(m: MarioState, fastAction: integer, slowAction: integer) Handles the scenario where Mario slides into a wall. If Mario is moving fast, reflects his velocity and transitions to a fast knockback, Otherwise, stops his forward velocity and sets a slower knockback
---- @field public set_triple_jump_action fun(m: MarioState, action: integer, actionArg: integer): integer Determines the proper triple jump action based on Mario's forward velocity and the Wing Cap flag: Normal triple jump, flying triple jump, or just a single jump if not enough speed
+--- @field public set_triple_jump_action fun(m: MarioState, action: integer, actionArg: integer): boolean Determines the proper triple jump action based on Mario's forward velocity and the Wing Cap flag: Normal triple jump, flying triple jump, or just a single jump if not enough speed
 --- @field public update_sliding_angle fun(m: MarioState, accel: number, lossFactor: number) Adjusts Mario's slide velocity and facing angle when on a slope. Calculates slope direction and steepness, then modifies velocity accordingly (speed up downhill, slow uphill). Handles facing-direction changes and maximum speed limits
---- @field public update_sliding fun(m: MarioState, stopSpeed: number): integer Updates Mario's sliding state each frame, applying additional friction or acceleration based on the surface's slipperiness. Also checks if speed has slowed below a threshold to end the slide. Returns `true` if sliding has stopped
+--- @field public update_sliding fun(m: MarioState, stopSpeed: number): boolean Updates Mario's sliding state each frame, applying additional friction or acceleration based on the surface's slipperiness. Also checks if speed has slowed below a threshold to end the slide. Returns `true` if sliding has stopped
 --- @field public apply_slope_accel fun(m: MarioState) Applies acceleration or deceleration based on the slope of the floor. On downward slopes, Mario gains speed, while on upward slopes, Mario loses speed
---- @field public apply_landing_accel fun(m: MarioState, frictionFactor: number): integer Applies friction-like deceleration if the floor is flat, or slope-based acceleration if the floor is sloped. Capped in such a way that Mario eventually stops or stabilizes on flatter ground
+--- @field public apply_landing_accel fun(m: MarioState, frictionFactor: number): boolean Applies friction-like deceleration if the floor is flat, or slope-based acceleration if the floor is sloped. Capped in such a way that Mario eventually stops or stabilizes on flatter ground
 --- @field public update_shell_speed fun(m: MarioState) Controls Mario's speed when riding a Koopa Shell on the ground.
---- @field public apply_slope_decel fun(m: MarioState, decelCoef: number): integer Approaches Mario's forward velocity toward zero at a rate dependent on the floor's slipperiness. This function can completely stop Mario if the slope is gentle enough or if friction is high
---- @field public update_decelerating_speed fun(m: MarioState): integer Gradually reduces Mario's forward speed to zero over time on level ground, unless otherwise influenced by slope or friction. Returns true if Mario's speed reaches zero, meaning he has stopped
+--- @field public apply_slope_decel fun(m: MarioState, decelCoef: number): boolean Approaches Mario's forward velocity toward zero at a rate dependent on the floor's slipperiness. This function can completely stop Mario if the slope is gentle enough or if friction is high
+--- @field public update_decelerating_speed fun(m: MarioState): boolean Gradually reduces Mario's forward speed to zero over time on level ground, unless otherwise influenced by slope or friction. Returns true if Mario's speed reaches zero, meaning he has stopped
 --- @field public update_walking_speed fun(m: MarioState) Updates Mario's walking speed based on player input and floor conditions (e.g., a slow floor or quicksand). Caps speed at a certain value and may reduce it slightly on steep slopes
---- @field public should_begin_sliding fun(m: MarioState): integer Checks if Mario should begin sliding, based on player input (facing downhill, pressing the analog stick backward, or on a slide terrain), and current floor steepness. Returns true if conditions to slide are met.
---- @field public analog_stick_held_back fun(m: MarioState): integer Checks if the analog stick is held significantly behind Mario's current facing angle. Returns true if the stick is far enough in the opposite direction, indicating Mario wants to move backward
---- @field public check_ground_dive_or_punch fun(m: MarioState): integer Checks if the B button was pressed to either initiate a dive (if moving fast enough) or a punch (if moving slowly). Returns `true` if the action was changed to either a dive or a punching attack
---- @field public begin_braking_action fun(m: MarioState): integer Begins a braking action if Mario's forward velocity is high enough or transitions to a decelerating action otherwise. Also handles the scenario where Mario is up against a wall, transitioning to a standing state
+--- @field public should_begin_sliding fun(m: MarioState): boolean Checks if Mario should begin sliding, based on player input (facing downhill, pressing the analog stick backward, or on a slide terrain), and current floor steepness. Returns true if conditions to slide are met.
+--- @field public analog_stick_held_back fun(m: MarioState): boolean Checks if the analog stick is held significantly behind Mario's current facing angle. Returns true if the stick is far enough in the opposite direction, indicating Mario wants to move backward
+--- @field public check_ground_dive_or_punch fun(m: MarioState): boolean Checks if the B button was pressed to either initiate a dive (if moving fast enough) or a punch (if moving slowly). Returns `true` if the action was changed to either a dive or a punching attack
+--- @field public begin_braking_action fun(m: MarioState): boolean Begins a braking action if Mario's forward velocity is high enough or transitions to a decelerating action otherwise. Also handles the scenario where Mario is up against a wall, transitioning to a standing state
 --- @field public anim_and_audio_for_walk fun(m: MarioState) Handles the animation and audio (footstep sounds) for normal walking or running. The specific animation used (tiptoe, walk, or run) depends on Mario's current speed
 --- @field public anim_and_audio_for_hold_walk fun(m: MarioState) Plays the appropriate animation and footstep sounds for walking while carrying a lighter object (like a small box). Adjusts the animation speed dynamically based on Mario's velocity
 --- @field public anim_and_audio_for_heavy_walk fun(m: MarioState) Plays the appropriate animation and footstep sounds for walking while carrying a heavy object. Sets the character animation speed based on Mario's intended movement speed
@@ -1358,38 +1358,37 @@
 --- @field public tilt_body_ground_shell fun(m: MarioState, startYaw: integer) Tilts Mario's torso and head while riding a shell on the ground to reflect turning. Similar to other tilt functions but tuned for shell-riding speeds and angles
 --- @field public tilt_body_butt_slide fun(m: MarioState) Tilts Mario's torso while butt sliding based on analog input direction and magnitude. Gives the appearance that Mario is balancing or leaning into a turn
 --- @field public common_slide_action fun(m: MarioState, endAction: integer, airAction: integer, animation: integer) Applies shared logic for sliding-related actions while playing sliding sounds, managing ground steps (falling off edges, hitting walls), updates animation
---- @field public common_slide_action_with_jump fun(m: MarioState, stopAction: integer, jumpAction: integer, airAction: integer, animation: integer): integer Builds on `common_slide_action` by also allowing Mario to jump out of a slide if A is pressed after a short delay. If the sliding slows enough, Mario transitions to a specified stopping action
---- @field public stomach_slide_action fun(m: MarioState, stopAction: integer, airAction: integer, animation: integer): integer Updates Mario's sliding state where he is on his stomach. Similar to other slide actions but has a chance to roll out if A or B is pressed. Uses `common_slide_action` for the core movement logic
---- @field public common_ground_knockback_action fun(m: MarioState, animation: integer, arg2: integer, arg3: integer, arg4: integer): integer Handles knockback on the ground (getting hit while on the ground) with shared logic for multiple knockback states. Applies deceleration or minimal momentum, chooses appropriate landing action if Mario leaves the ground, and handles death transitions if Mario's health is depleted
---- @field public common_landing_action fun(m: MarioState, animation: integer, airAction: integer): integer Applies movement upon landing from a jump or fall. Adjusts velocity based on slope or friction, checks for transitions like sliding or hitting a wall, handles small dust particles if moving fast
---- @field public common_landing_cancels function 
+--- @field public common_slide_action_with_jump fun(m: MarioState, stopAction: integer, jumpAction: integer, airAction: integer, animation: integer): boolean Builds on `common_slide_action` by also allowing Mario to jump out of a slide if A is pressed after a short delay. If the sliding slows enough, Mario transitions to a specified stopping action
+--- @field public stomach_slide_action fun(m: MarioState, stopAction: integer, airAction: integer, animation: integer): boolean Updates Mario's sliding state where he is on his stomach. Similar to other slide actions but has a chance to roll out if A or B is pressed. Uses `common_slide_action` for the core movement logic
+--- @field public common_ground_knockback_action fun(m: MarioState, animation: integer, arg2: integer, arg3: integer, arg4: integer): boolean Handles knockback on the ground (getting hit while on the ground) with shared logic for multiple knockback states. Applies deceleration or minimal momentum, chooses appropriate landing action if Mario leaves the ground, and handles death transitions if Mario's health is depleted
+--- @field public common_landing_action fun(m: MarioState, animation: integer, airAction: integer): boolean Applies movement upon landing from a jump or fall. Adjusts velocity based on slope or friction, checks for transitions like sliding or hitting a wall, handles small dust particles if moving fast
 --- @field public quicksand_jump_land_action fun(m: MarioState, animation1: integer, animation2: integer, endAction: integer, airAction: integer): integer Handles a special landing in quicksand after a jump. Over several frames, Mario emerges from the quicksand. First part of the animation reduces his quicksand depth. Ends with a normal landing action or transitions back to air if he leaves the ground
---- @field public check_common_moving_cancels fun(m: MarioState): integer Performs common checks when Mario is in a moving state, transitions to water plunge if underwater, handles squished or shockwave bounce scenarios, and checks for death conditions
---- @field public execute_moving_action fun(m: MarioState): integer Executes Mario's current moving actions by: checking common cancellations (e.g., water plunge, squish, death), handling quicksand updates, and switching to the correct sub-action handler based on `m.action`
+--- @field public check_common_moving_cancels fun(m: MarioState): boolean Performs common checks when Mario is in a moving state, transitions to water plunge if underwater, handles squished or shockwave bounce scenarios, and checks for death conditions
+--- @field public execute_moving_action fun(m: MarioState): boolean Executes Mario's current moving actions by: checking common cancellations (e.g., water plunge, squish, death), handling quicksand updates, and switching to the correct sub-action handler based on `m.action`
 --- @field public animated_stationary_ground_step fun(m: MarioState, animation: integer, endAction: integer) Performs a stationary step, sets `m`'s animation and sets action to `endAction` once the animation finishes
---- @field public update_punch_sequence fun(m: MarioState): integer Updates Mario's punching state
---- @field public check_common_object_cancels fun(m: MarioState): integer Checks for and handles common conditions that would cancel Mario's current object action. This includes transitioning to a water plunge if below the water level, becoming squished if appropriate, or switching to standing death action if Mario is dead
---- @field public execute_object_action fun(m: MarioState): integer Executes Mario's current object action by first checking common object cancels, then updating quicksand state. Dispatches to the appropriate action function, such as punching, throwing, picking up Bowser, etc
---- @field public check_common_idle_cancels fun(m: MarioState): integer Checks for and handles common conditions that would cancel Mario's current idle action.
---- @field public check_common_hold_idle_cancels fun(m: MarioState): integer Checks for and handles common conditions that would cancel Mario's current idle holding object action.
+--- @field public update_punch_sequence fun(m: MarioState): boolean Updates Mario's punching state
+--- @field public check_common_object_cancels fun(m: MarioState): boolean Checks for and handles common conditions that would cancel Mario's current object action. This includes transitioning to a water plunge if below the water level, becoming squished if appropriate, or switching to standing death action if Mario is dead
+--- @field public execute_object_action fun(m: MarioState): boolean Executes Mario's current object action by first checking common object cancels, then updating quicksand state. Dispatches to the appropriate action function, such as punching, throwing, picking up Bowser, etc
+--- @field public check_common_idle_cancels fun(m: MarioState): boolean Checks for and handles common conditions that would cancel Mario's current idle action.
+--- @field public check_common_hold_idle_cancels fun(m: MarioState): boolean Checks for and handles common conditions that would cancel Mario's current idle holding object action.
 --- @field public play_anim_sound fun(m: MarioState, actionState: integer, animFrame: integer, sound: integer) Plays a `sound` if Mario's action state and animation frame match the parameters
 --- @field public stopping_step fun(m: MarioState, animID: integer, action: integer) Runs a stationary step, sets the character animation, and changes action if the animation has ended
---- @field public landing_step fun(m: MarioState, animID: integer, action: integer): integer Runs a stationary step, sets the character animation, and changes action if the animation has ended
---- @field public check_common_landing_cancels fun(m: MarioState, action: integer): integer Checks for and handles common conditions that would cancel Mario's current landing action.
---- @field public exit_palette_editor fun(m: MarioState, c: Camera): integer 
---- @field public check_common_stationary_cancels fun(m: MarioState): integer Checks for and handles common conditions that would cancel Mario's current stationary action.
---- @field public execute_stationary_action fun(m: MarioState): integer Executes Mario's current object action by first checking common stationary cancels, then updating quicksand state. Dispatches to the appropriate action function, such as idle, sleeping, crouching, ect
+--- @field public landing_step fun(m: MarioState, animID: integer, action: integer): boolean Runs a stationary step, sets the character animation, and changes action if the animation has ended
+--- @field public check_common_landing_cancels fun(m: MarioState, action: integer): boolean Checks for and handles common conditions that would cancel Mario's current landing action.
+--- @field public exit_palette_editor fun(m: MarioState, c: Camera): boolean 
+--- @field public check_common_stationary_cancels fun(m: MarioState): boolean Checks for and handles common conditions that would cancel Mario's current stationary action.
+--- @field public execute_stationary_action fun(m: MarioState): boolean Executes Mario's current object action by first checking common stationary cancels, then updating quicksand state. Dispatches to the appropriate action function, such as idle, sleeping, crouching, ect
 --- @field public set_swimming_at_surface_particles fun(m: MarioState, particleFlag: integer) Sets Mario's particle flags if he's at the surface of a water box
 --- @field public perform_water_full_step fun(m: MarioState, nextPos: Vec3f): integer Performs a full water movement step where ceilings, floors, and walls are handled. Generally, you should use `perform_water_step` for the full step functionality
 --- @field public apply_water_current fun(m: MarioState, step: Vec3f) Calculates a water current and outputs it in `step`
 --- @field public perform_water_step fun(m: MarioState): integer Performs a water step
 --- @field public float_surface_gfx fun(m: MarioState) Controls the bobbing that happens when you swim near the water surface
---- @field public execute_submerged_action fun(m: MarioState): integer Executes Mario's current submerged action by first checking common submerged cancels, then setting quicksand depth and head angles to 0. Dispatches to the appropriate action function, such as breaststroke, flutterkick, water punch, ect
+--- @field public execute_submerged_action fun(m: MarioState): boolean Executes Mario's current submerged action by first checking common submerged cancels, then setting quicksand depth and head angles to 0. Dispatches to the appropriate action function, such as breaststroke, flutterkick, water punch, ect
 --- @field public bonk_reflection fun(m: MarioState, negateSpeed: integer) Reflects Mario off a wall if he is colliding with one and flips forward velocity if `negateSpeed` is TRUE
---- @field public update_quicksand fun(m: MarioState, sinkingSpeed: number): integer Updates Mario's state in quicksand, sinks him at `sinkingSpeed` if he's in non instant quicksand
---- @field public push_off_steep_floor fun(m: MarioState, action: integer, actionArg: integer): integer Pushes Mario off a steep floor and sets his action to `action` with `actionArg`
---- @field public update_moving_sand fun(m: MarioState): integer Pushes Mario in the direction of the quicksand based on the floor surface
---- @field public update_windy_ground fun(m: MarioState): integer Pushes Mario in the direction of the wind based on the floor surface
+--- @field public update_quicksand fun(m: MarioState, sinkingSpeed: number): boolean Updates Mario's state in quicksand, sinks him at `sinkingSpeed` if he's in non instant quicksand
+--- @field public push_off_steep_floor fun(m: MarioState, action: integer, actionArg: integer): boolean Pushes Mario off a steep floor and sets his action to `action` with `actionArg`
+--- @field public update_moving_sand fun(m: MarioState): boolean Pushes Mario in the direction of the quicksand based on the floor surface
+--- @field public update_windy_ground fun(m: MarioState): boolean Pushes Mario in the direction of the wind based on the floor surface
 --- @field public stop_and_set_height_to_floor fun(m: MarioState) Sets all of Mario's velocity variables to 0 and sets his Y position to the floor height
 --- @field public stationary_ground_step fun(m: MarioState): integer Performs a full Mario stationary physics step (4 substeps) and returns a `GROUND_STEP_*` result
 --- @field public perform_ground_step fun(m: MarioState): integer Performs a full Mario ground physics step (4 substeps) and returns a `GROUND_STEP_*` result
@@ -1397,19 +1396,19 @@
 --- @field public set_vel_from_pitch_and_yaw fun(m: MarioState) Sets Mario's velocity to his forward velocity multiplied by the cosine and sine of his pitch and yaw
 --- @field public spline_get_weights fun(m: MarioState, result: Vec4f, t: number, c: integer) Computes spline interpolation weights for a given parameter `t` and stores these weights in `result`. This is used in spline-based animations to find intermediate positions between keyframes
 --- @field public anim_spline_init fun(m: MarioState, keyFrames: Pointer_Vec4s) Initializes a spline-based animation for the `MarioState` structure `m` using the provided array of 3D signed-integer vectors `keyFrames`. This sets up the animation so that it can be advanced by polling
---- @field public anim_spline_poll fun(m: MarioState, result: Vec3f): integer Advances the spline-based animation associated with `m` and stores the current interpolated position in `result`. It returns the animation's status, allowing the caller to determine if the animation is ongoing or has completed
---- @field public is_player_active fun(m: MarioState): integer Checks if `m` is in the current course/act/level/area and isn't bubbled
---- @field public is_player_in_local_area fun(m: MarioState): integer Checks if `m` is in the current course/act/level/area
---- @field public is_nearest_state_to_object fun(m: MarioState, obj: Object): integer Checks if `m` is the nearest Mario to `obj`
---- @field public obj_is_near_to_and_facing fun(m: MarioState, maxDist: number, maxAngleDiff: integer): integer Checks if the current object is in `maxDist` to `m` and the angle difference is less than `maxAngleDiff`
+--- @field public anim_spline_poll fun(m: MarioState, result: Vec3f): boolean Advances the spline-based animation associated with `m` and stores the current interpolated position in `result`. It returns the animation's status, allowing the caller to determine if the animation is ongoing or has completed
+--- @field public is_player_active fun(m: MarioState): boolean Checks if `m` is in the current course/act/level/area and isn't bubbled
+--- @field public is_player_in_local_area fun(m: MarioState): boolean Checks if `m` is in the current course/act/level/area
+--- @field public is_nearest_state_to_object fun(m: MarioState, obj: Object): boolean Checks if `m` is the nearest Mario to `obj`
+--- @field public obj_is_near_to_and_facing fun(m: MarioState, maxDist: number, maxAngleDiff: integer): boolean Checks if the current object is in `maxDist` to `m` and the angle difference is less than `maxAngleDiff`
 --- @field public obj_turn_pitch_toward fun(m: MarioState, targetOffsetY: number, turnAmount: integer): integer Turns the current object towards `m` by `turnAmount` and subtracts and adds `targetOffsetY` to the Y position, effectively cancelling any effect out
 --- @field public cur_obj_set_vel_from_vel fun(m: MarioState, f12: number, f14: number) 
---- @field public is_in_air_action fun(m: MarioState): integer 
---- @field public is_dive_sliding fun(m: MarioState): integer 
+--- @field public is_in_air_action fun(m: MarioState): boolean 
+--- @field public is_dive_sliding fun(m: MarioState): boolean 
 --- @field public cur_obj_spawn_loot_coin_at_pos fun(m: MarioState) 
---- @field public obj_is_ground_pounding_platform fun(m: MarioState, obj: Object): integer 
---- @field public cur_obj_can_activate_textbox fun(m: MarioState, radius: number, height: number, unused: integer): integer 
---- @field public cur_obj_can_activate_textbox_2 fun(m: MarioState, radius: number, height: number): integer 
+--- @field public obj_is_ground_pounding_platform fun(m: MarioState, obj: Object): boolean 
+--- @field public cur_obj_can_activate_textbox fun(m: MarioState, radius: number, height: number, unused: integer): boolean 
+--- @field public cur_obj_can_activate_textbox_2 fun(m: MarioState, radius: number, height: number): boolean 
 --- @field public cur_obj_end_dialog fun(m: MarioState, dialogFlags: integer, dialogResult: integer) 
 --- @field public queue_rumble_data fun(m: MarioState, a0: integer, a1: integer) Queues rumble data for Mario
 --- @field public reset_rumble_timers fun(m: MarioState) Resets rumble timers
@@ -2311,13 +2310,13 @@
 --- @field public nearest_player_to fun(obj: Object): Object Gets the nearest player (Mario Object) to `obj`
 --- @field public nearest_interacting_mario_state_to fun(obj: Object): MarioState Gets the nearest interacting Mario to `obj`
 --- @field public nearest_interacting_player_to fun(obj: Object): Object Gets the nearest interacting player (Mario Object) to `obj`
---- @field public is_nearest_player_to fun(m: Object, obj: Object): integer Checks if `m` is the nearest player (Mario Object) to `obj`
---- @field public is_point_close_to fun(obj: Object, x: number, y: number, z: number, dist: integer): integer Checks if a point is within `dist` of `obj`
+--- @field public is_nearest_player_to fun(m: Object, obj: Object): boolean Checks if `m` is the nearest player (Mario Object) to `obj`
+--- @field public is_point_close_to fun(obj: Object, x: number, y: number, z: number, dist: integer): boolean Checks if a point is within `dist` of `obj`
 --- @field public set_visibility fun(obj: Object, dist: integer) Sets an object as visible if within a certain distance of Mario's graphical position
---- @field public return_home_if_safe fun(obj: Object, homeX: number, y: number, homeZ: number, dist: integer): integer Turns an object towards home if Mario is not near to it
+--- @field public return_home_if_safe fun(obj: Object, homeX: number, y: number, homeZ: number, dist: integer): boolean Turns an object towards home if Mario is not near to it
 --- @field public return_and_displace_home fun(obj: Object, homeX: number, homeY: number, homeZ: number, baseDisp: integer) Randomly displaces an objects home if RNG says to, and turns the object towards its home
 --- @field public spawn_yellow_coins fun(obj: Object, nCoins: integer) Spawns a number of coins at the location of an object with a random forward velocity, y velocity, and direction
---- @field public flicker_and_disappear fun(obj: Object, lifeSpan: integer): integer Controls whether certain objects should flicker/when to despawn
+--- @field public flicker_and_disappear fun(obj: Object, lifeSpan: integer): boolean Controls whether certain objects should flicker/when to despawn
 --- @field public apply_scale_to_matrix fun(obj: Object, dst: Mat4, src: Mat4) 
 --- @field public set_held_state fun(obj: Object, heldBehavior: Pointer_BehaviorScript) 
 --- @field public lateral_dist_betweens fun(obj1: Object, obj2: Object): number 
@@ -2355,9 +2354,9 @@
 --- @field public set_face_angle_to_move_angle fun(obj: Object) 
 --- @field public mark_for_deletion fun(obj: Object) Marks an object to be unloaded at the end of the frame
 --- @field public become_tangible fun(obj: Object) 
---- @field public check_if_collided_with fun(obj1: Object, obj2: Object): integer 
+--- @field public check_if_collided_with fun(obj1: Object, obj2: Object): boolean 
 --- @field public set_behavior fun(obj: Object, behavior: Pointer_BehaviorScript) 
---- @field public has_behavior fun(obj: Object, behavior: Pointer_BehaviorScript): integer 
+--- @field public has_behavior fun(obj: Object, behavior: Pointer_BehaviorScript): boolean 
 --- @field public cur_lateral_dist_from_obj_to_home fun(obj: Object): number 
 --- @field public cur_start_cam_event fun(obj: Object, cameraEvent: integer) 
 --- @field public set_billboard fun(obj: Object) 
@@ -2380,16 +2379,16 @@
 --- @field public build_vel_from_transform fun(a0: Object) 
 --- @field public set_hitbox fun(obj: Object, hitbox: ObjectHitbox) 
 --- @field public set_collision_data function 
---- @field public is_hidden fun(obj: Object): integer 
---- @field public attack_collided_from_other fun(obj: Object): integer 
+--- @field public is_hidden fun(obj: Object): boolean 
+--- @field public attack_collided_from_other fun(obj: Object): boolean 
 --- @field public copy_behavior_params fun(dst: Object, src: Object) 
 --- @field public set_respawn_info_bits fun(obj: Object, bits: integer) Runs an OR operator on the `obj`'s respawn info with `bits` << 8. If `bits` is 0xFF, this prevents the object from respawning after leaving and re-entering the area
 --- @field public apply_platform_displacement fun(o: Object, platform: Object) Apply one frame of platform rotation to the object using the given platform
 --- @field public queue_rumble_data fun(object: Object, a0: integer, a1: integer) Queues rumble data for object, factoring in its distance from Mario
 --- @field public smlua_anim_util_set_animation fun(obj: Object, name: string) Sets the animation of `obj` to the animation `name` corresponds to
 --- @field public smlua_anim_util_get_current_animation_name fun(obj: Object): string Gets the name of the current animation playing on `obj`, returns `nil` if there's no name
---- @field public has_behavior_id fun(o: Object, behaviorId: BehaviorId): integer Checks if an object has `behaviorId`
---- @field public has_model_extended fun(o: Object, modelId: ModelExtendedId): integer Checks if an object's model is equal to `modelId`
+--- @field public has_behavior_id fun(o: Object, behaviorId: BehaviorId): boolean Checks if an object has `behaviorId`
+--- @field public has_model_extended fun(o: Object, modelId: ModelExtendedId): boolean Checks if an object's model is equal to `modelId`
 --- @field public get_model_id_extended fun(o: Object): ModelExtendedId Returns an object's extended model id
 --- @field public set_model_extended fun(o: Object, modelId: ModelExtendedId) Sets an object's model to `modelId`
 --- @field public set_cutscene_focus fun(o: Object) Sets the cutscene focus object
@@ -2624,7 +2623,7 @@
 --- @field public originOffset number
 --- @field public modifiedTimestamp integer
 --- @field public object Object
---- @field public turn_obj_away_from_steep_floor fun(objFloor: Surface, floorY: number, objVelX: number, objVelZ: number): integer Turns an object away from steep floors, similarly to walls.
+--- @field public turn_obj_away_from_steep_floor fun(objFloor: Surface, floorY: number, objVelX: number, objVelZ: number): boolean Turns an object away from steep floors, similarly to walls.
 --- @field public calc_new_obj_vel_and_pos_y fun(objFloor: Surface, objFloorY: number, objVelX: number, objVelZ: number) Updates an objects speed for gravity and updates Y position.
 --- @field public calc_new_obj_vel_and_pos_y_underwater fun(objFloor: Surface, floorY: number, objVelX: number, objVelZ: number, waterY: number) Adjusts the current object's veloicty and y position for being underwater
 --- @field public is_quicksand fun(surf: Surface): boolean Checks if the surface is quicksand

src/pc/lua/smlua_cobject_autogen.c

@@ -1387,325 +1387,324 @@ static struct LuaObjectField sMarioBodyStateFields[LUA_MARIO_BODY_STATE_FIELD_CO
     { "wingFlutter",         LVT_S8,      offsetof(struct MarioBodyState, wingFlutter),         false, LOT_NONE,  1,                   sizeof(s8)    },
 };
 
-#define LUA_MARIO_STATE_FIELD_COUNT 317
+#define LUA_MARIO_STATE_FIELD_COUNT 316
 static struct LuaObjectField sMarioStateFields[LUA_MARIO_STATE_FIELD_COUNT] = {
-    { "action",                            LVT_U32,       offsetof(struct MarioState, action),                    false, LOT_NONE,              1, sizeof(u32)                       },
-    { "actionArg",                         LVT_U32,       offsetof(struct MarioState, actionArg),                 false, LOT_NONE,              1, sizeof(u32)                       },
-    { "actionState",                       LVT_U16,       offsetof(struct MarioState, actionState),               false, LOT_NONE,              1, sizeof(u16)                       },
-    { "actionTimer",                       LVT_U16,       offsetof(struct MarioState, actionTimer),               false, LOT_NONE,              1, sizeof(u16)                       },
-    { "add_tree_leaf_particles",           LVT_FUNCTION,  (size_t) "add_tree_leaf_particles",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "adjust_sound_for_speed",            LVT_FUNCTION,  (size_t) "adjust_sound_for_speed",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "align_with_floor",                  LVT_FUNCTION,  (size_t) "align_with_floor",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "analog_stick_held_back",            LVT_FUNCTION,  (size_t) "analog_stick_held_back",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "angleVel",                          LVT_COBJECT,   offsetof(struct MarioState, angleVel),                  true,  LOT_VEC3S,             1, sizeof(Vec3s)                     },
-    { "anim_and_audio_for_heavy_walk",     LVT_FUNCTION,  (size_t) "anim_and_audio_for_heavy_walk",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "anim_and_audio_for_hold_walk",      LVT_FUNCTION,  (size_t) "anim_and_audio_for_hold_walk",                true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "anim_and_audio_for_walk",           LVT_FUNCTION,  (size_t) "anim_and_audio_for_walk",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "anim_spline_init",                  LVT_FUNCTION,  (size_t) "anim_spline_init",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "anim_spline_poll",                  LVT_FUNCTION,  (size_t) "anim_spline_poll",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "animated_stationary_ground_step",   LVT_FUNCTION,  (size_t) "animated_stationary_ground_step",             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "animation",                         LVT_COBJECT_P, offsetof(struct MarioState, animation),                 false, LOT_MARIOANIMATION,    1, sizeof(struct MarioAnimation*)    },
-    { "apply_landing_accel",               LVT_FUNCTION,  (size_t) "apply_landing_accel",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "apply_slope_accel",                 LVT_FUNCTION,  (size_t) "apply_slope_accel",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "apply_slope_decel",                 LVT_FUNCTION,  (size_t) "apply_slope_decel",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "apply_water_current",               LVT_FUNCTION,  (size_t) "apply_water_current",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "area",                              LVT_COBJECT_P, offsetof(struct MarioState, area),                      true,  LOT_AREA,              1, sizeof(struct Area*)              },
-    { "begin_braking_action",              LVT_FUNCTION,  (size_t) "begin_braking_action",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "begin_walking_action",              LVT_FUNCTION,  (size_t) "begin_walking_action",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "blow_off_cap",                      LVT_FUNCTION,  (size_t) "mario_blow_off_cap",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "bonk_reflection",                   LVT_FUNCTION,  (size_t) "mario_bonk_reflection",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "bounceSquishTimer",                 LVT_U8,        offsetof(struct MarioState, bounceSquishTimer),         false, LOT_NONE,              1, sizeof(u8)                        },
-    { "bubbleObj",                         LVT_COBJECT_P, offsetof(struct MarioState, bubbleObj),                 false, LOT_OBJECT,            1, sizeof(struct Object*)            },
-    { "can_bubble",                        LVT_FUNCTION,  (size_t) "mario_can_bubble",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "cap",                               LVT_U32,       offsetof(struct MarioState, cap),                       false, LOT_NONE,              1, sizeof(u32)                       },
-    { "capTimer",                          LVT_U16,       offsetof(struct MarioState, capTimer),                  false, LOT_NONE,              1, sizeof(u16)                       },
-    { "ceil",                              LVT_COBJECT_P, offsetof(struct MarioState, ceil),                      false, LOT_SURFACE,           1, sizeof(struct Surface*)           },
-    { "ceilHeight",                        LVT_F32,       offsetof(struct MarioState, ceilHeight),                false, LOT_NONE,              1, sizeof(f32)                       },
-    { "character",                         LVT_COBJECT_P, offsetof(struct MarioState, character),                 false, LOT_CHARACTER,         1, sizeof(struct Character*)         },
-    { "check_common_action_exits",         LVT_FUNCTION,  (size_t) "check_common_action_exits",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_common_airborne_cancels",     LVT_FUNCTION,  (size_t) "check_common_airborne_cancels",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_common_automatic_cancels",    LVT_FUNCTION,  (size_t) "check_common_automatic_cancels",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_common_hold_action_exits",    LVT_FUNCTION,  (size_t) "check_common_hold_action_exits",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_common_hold_idle_cancels",    LVT_FUNCTION,  (size_t) "check_common_hold_idle_cancels",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_common_idle_cancels",         LVT_FUNCTION,  (size_t) "check_common_idle_cancels",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_common_landing_cancels",      LVT_FUNCTION,  (size_t) "check_common_landing_cancels",                true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_common_moving_cancels",       LVT_FUNCTION,  (size_t) "check_common_moving_cancels",                 true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_common_object_cancels",       LVT_FUNCTION,  (size_t) "check_common_object_cancels",                 true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_common_stationary_cancels",   LVT_FUNCTION,  (size_t) "check_common_stationary_cancels",             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_fall_damage",                 LVT_FUNCTION,  (size_t) "check_fall_damage",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_fall_damage_or_get_stuck",    LVT_FUNCTION,  (size_t) "check_fall_damage_or_get_stuck",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_ground_dive_or_punch",        LVT_FUNCTION,  (size_t) "check_ground_dive_or_punch",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_horizontal_wind",             LVT_FUNCTION,  (size_t) "check_horizontal_wind",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_kick_or_dive_in_air",         LVT_FUNCTION,  (size_t) "check_kick_or_dive_in_air",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_ledge_climb_down",            LVT_FUNCTION,  (size_t) "check_ledge_climb_down",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_object_grab",                 LVT_FUNCTION,  (size_t) "mario_check_object_grab",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "check_wall_kick",                   LVT_FUNCTION,  (size_t) "check_wall_kick",                             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "climb_up_ledge",                    LVT_FUNCTION,  (size_t) "climb_up_ledge",                              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "collidedObjInteractTypes",          LVT_U32,       offsetof(struct MarioState, collidedObjInteractTypes),  false, LOT_NONE,              1, sizeof(u32)                       },
-    { "common_air_action_step",            LVT_FUNCTION,  (size_t) "common_air_action_step",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "common_air_knockback_step",         LVT_FUNCTION,  (size_t) "common_air_knockback_step",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "common_death_handler",              LVT_FUNCTION,  (size_t) "common_death_handler",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "common_ground_knockback_action",    LVT_FUNCTION,  (size_t) "common_ground_knockback_action",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "common_landing_action",             LVT_FUNCTION,  (size_t) "common_landing_action",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "common_landing_cancels",            LVT_FUNCTION,  (size_t) "common_landing_cancels",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "common_slide_action",               LVT_FUNCTION,  (size_t) "common_slide_action",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "common_slide_action_with_jump",     LVT_FUNCTION,  (size_t) "common_slide_action_with_jump",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "controller",                        LVT_COBJECT_P, offsetof(struct MarioState, controller),                true,  LOT_CONTROLLER,        1, sizeof(struct Controller*)        },
-    { "curAnimOffset",                     LVT_F32,       offsetof(struct MarioState, curAnimOffset),             false, LOT_NONE,              1, sizeof(f32)                       },
-    { "cur_obj_can_activate_textbox",      LVT_FUNCTION,  (size_t) "cur_obj_can_mario_activate_textbox",          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "cur_obj_can_activate_textbox_2",    LVT_FUNCTION,  (size_t) "cur_obj_can_mario_activate_textbox_2",        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "cur_obj_end_dialog",                LVT_FUNCTION,  (size_t) "cur_obj_end_dialog",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "cur_obj_set_vel_from_vel",          LVT_FUNCTION,  (size_t) "cur_obj_set_vel_from_mario_vel",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "cur_obj_spawn_loot_coin_at_pos",    LVT_FUNCTION,  (size_t) "cur_obj_spawn_loot_coin_at_mario_pos",        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "currentRoom",                       LVT_S16,       offsetof(struct MarioState, currentRoom),               false, LOT_NONE,              1, sizeof(s16)                       },
-    { "cutscene_put_cap_on",               LVT_FUNCTION,  (size_t) "cutscene_put_cap_on",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "cutscene_take_cap_off",             LVT_FUNCTION,  (size_t) "cutscene_take_cap_off",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "determine_interaction",             LVT_FUNCTION,  (size_t) "determine_interaction",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "dialogId",                          LVT_S32,       offsetof(struct MarioState, dialogId),                  true,  LOT_NONE,              1, sizeof(s32)                       },
-    { "does_have_blown_cap",               LVT_FUNCTION,  (size_t) "does_mario_have_blown_cap",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "does_have_normal_cap_on_head",      LVT_FUNCTION,  (size_t) "does_mario_have_normal_cap_on_head",          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "doubleJumpTimer",                   LVT_U8,        offsetof(struct MarioState, doubleJumpTimer),           false, LOT_NONE,              1, sizeof(u8)                        },
-    { "drop_and_set_action",               LVT_FUNCTION,  (size_t) "drop_and_set_mario_action",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "drop_held_object",                  LVT_FUNCTION,  (size_t) "mario_drop_held_object",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "execute_airborne_action",           LVT_FUNCTION,  (size_t) "mario_execute_airborne_action",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "execute_automatic_action",          LVT_FUNCTION,  (size_t) "mario_execute_automatic_action",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "execute_cutscene_action",           LVT_FUNCTION,  (size_t) "mario_execute_cutscene_action",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "execute_moving_action",             LVT_FUNCTION,  (size_t) "mario_execute_moving_action",                 true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "execute_object_action",             LVT_FUNCTION,  (size_t) "mario_execute_object_action",                 true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "execute_stationary_action",         LVT_FUNCTION,  (size_t) "mario_execute_stationary_action",             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "execute_submerged_action",          LVT_FUNCTION,  (size_t) "mario_execute_submerged_action",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "exit_palette_editor",               LVT_FUNCTION,  (size_t) "mario_exit_palette_editor",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "faceAngle",                         LVT_COBJECT,   offsetof(struct MarioState, faceAngle),                 true,  LOT_VEC3S,             1, sizeof(Vec3s)                     },
-    { "facing_downhill",                   LVT_FUNCTION,  (size_t) "mario_facing_downhill",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "fadeWarpOpacity",                   LVT_U8,        offsetof(struct MarioState, fadeWarpOpacity),           false, LOT_NONE,              1, sizeof(u8)                        },
-    { "find_floor_height_relative_polar",  LVT_FUNCTION,  (size_t) "find_floor_height_relative_polar",            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "find_floor_slope",                  LVT_FUNCTION,  (size_t) "find_floor_slope",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "first_person_check_cancels",        LVT_FUNCTION,  (size_t) "first_person_check_cancels",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "flags",                             LVT_U32,       offsetof(struct MarioState, flags),                     false, LOT_NONE,              1, sizeof(u32)                       },
-    { "float_surface_gfx",                 LVT_FUNCTION,  (size_t) "float_surface_gfx",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "floor",                             LVT_COBJECT_P, offsetof(struct MarioState, floor),                     false, LOT_SURFACE,           1, sizeof(struct Surface*)           },
-    { "floorAngle",                        LVT_S16,       offsetof(struct MarioState, floorAngle),                false, LOT_NONE,              1, sizeof(s16)                       },
-    { "floorHeight",                       LVT_F32,       offsetof(struct MarioState, floorHeight),               false, LOT_NONE,              1, sizeof(f32)                       },
-    { "floor_is_slippery",                 LVT_FUNCTION,  (size_t) "mario_floor_is_slippery",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "floor_is_slope",                    LVT_FUNCTION,  (size_t) "mario_floor_is_slope",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "floor_is_steep",                    LVT_FUNCTION,  (size_t) "mario_floor_is_steep",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "force_idle_state",                  LVT_FUNCTION,  (size_t) "force_idle_state",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "forwardVel",                        LVT_F32,       offsetof(struct MarioState, forwardVel),                false, LOT_NONE,              1, sizeof(f32)                       },
-    { "framesSinceA",                      LVT_U8,        offsetof(struct MarioState, framesSinceA),              false, LOT_NONE,              1, sizeof(u8)                        },
-    { "framesSinceB",                      LVT_U8,        offsetof(struct MarioState, framesSinceB),              false, LOT_NONE,              1, sizeof(u8)                        },
-    { "freeze",                            LVT_U8,        offsetof(struct MarioState, freeze),                    false, LOT_NONE,              1, sizeof(u8)                        },
-    { "general_star_dance_handler",        LVT_FUNCTION,  (size_t) "general_star_dance_handler",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_anim_part_pos",                 LVT_FUNCTION,  (size_t) "get_mario_anim_part_pos",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_anim_part_rot",                 LVT_FUNCTION,  (size_t) "get_mario_anim_part_rot",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_character",                     LVT_FUNCTION,  (size_t) "get_character",                               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_character_anim",                LVT_FUNCTION,  (size_t) "get_character_anim",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_character_anim_offset",         LVT_FUNCTION,  (size_t) "get_character_anim_offset",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_collided_object",               LVT_FUNCTION,  (size_t) "mario_get_collided_object",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_floor_class",                   LVT_FUNCTION,  (size_t) "mario_get_floor_class",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_hand_foot_pos_x",               LVT_FUNCTION,  (size_t) "get_hand_foot_pos_x",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_hand_foot_pos_y",               LVT_FUNCTION,  (size_t) "get_hand_foot_pos_y",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_hand_foot_pos_z",               LVT_FUNCTION,  (size_t) "get_hand_foot_pos_z",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_star_collection_dialog",        LVT_FUNCTION,  (size_t) "get_star_collection_dialog",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "get_terrain_sound_addend",          LVT_FUNCTION,  (size_t) "mario_get_terrain_sound_addend",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "grab_used_object",                  LVT_FUNCTION,  (size_t) "mario_grab_used_object",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "handle_save_menu",                  LVT_FUNCTION,  (size_t) "handle_save_menu",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "healCounter",                       LVT_U8,        offsetof(struct MarioState, healCounter),               false, LOT_NONE,              1, sizeof(u8)                        },
-    { "health",                            LVT_S16,       offsetof(struct MarioState, health),                    false, LOT_NONE,              1, sizeof(s16)                       },
-    { "heldByObj",                         LVT_COBJECT_P, offsetof(struct MarioState, heldByObj),                 false, LOT_OBJECT,            1, sizeof(struct Object*)            },
-    { "heldObj",                           LVT_COBJECT_P, offsetof(struct MarioState, heldObj),                   false, LOT_OBJECT,            1, sizeof(struct Object*)            },
-    { "hurtCounter",                       LVT_U8,        offsetof(struct MarioState, hurtCounter),               false, LOT_NONE,              1, sizeof(u8)                        },
-    { "hurt_and_set_action",               LVT_FUNCTION,  (size_t) "hurt_and_set_mario_action",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "init_single",                       LVT_FUNCTION,  (size_t) "init_single_mario",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "input",                             LVT_U16,       offsetof(struct MarioState, input),                     false, LOT_NONE,              1, sizeof(u16)                       },
-    { "intendedMag",                       LVT_F32,       offsetof(struct MarioState, intendedMag),               false, LOT_NONE,              1, sizeof(f32)                       },
-    { "intendedYaw",                       LVT_S16,       offsetof(struct MarioState, intendedYaw),               false, LOT_NONE,              1, sizeof(s16)                       },
-    { "interactObj",                       LVT_COBJECT_P, offsetof(struct MarioState, interactObj),               false, LOT_OBJECT,            1, sizeof(struct Object*)            },
-    { "interact_bbh_entrance",             LVT_FUNCTION,  (size_t) "interact_bbh_entrance_SPOOFED",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_bounce_top",               LVT_FUNCTION,  (size_t) "interact_bounce_top_SPOOFED",                 true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_breakable",                LVT_FUNCTION,  (size_t) "interact_breakable_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_bully",                    LVT_FUNCTION,  (size_t) "interact_bully_SPOOFED",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_cannon_base",              LVT_FUNCTION,  (size_t) "interact_cannon_base_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_cap",                      LVT_FUNCTION,  (size_t) "interact_cap_SPOOFED",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_clam_or_bubba",            LVT_FUNCTION,  (size_t) "interact_clam_or_bubba_SPOOFED",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_coin",                     LVT_FUNCTION,  (size_t) "interact_coin_SPOOFED",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_damage",                   LVT_FUNCTION,  (size_t) "interact_damage_SPOOFED",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_door",                     LVT_FUNCTION,  (size_t) "interact_door_SPOOFED",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_flame",                    LVT_FUNCTION,  (size_t) "interact_flame_SPOOFED",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_grabbable",                LVT_FUNCTION,  (size_t) "interact_grabbable_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_hit_from_below",           LVT_FUNCTION,  (size_t) "interact_hit_from_below_SPOOFED",             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_hoot",                     LVT_FUNCTION,  (size_t) "interact_hoot_SPOOFED",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_igloo_barrier",            LVT_FUNCTION,  (size_t) "interact_igloo_barrier_SPOOFED",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_koopa_shell",              LVT_FUNCTION,  (size_t) "interact_koopa_shell_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_mr_blizzard",              LVT_FUNCTION,  (size_t) "interact_mr_blizzard_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_player",                   LVT_FUNCTION,  (size_t) "interact_player_SPOOFED",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_pole",                     LVT_FUNCTION,  (size_t) "interact_pole_SPOOFED",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_shock",                    LVT_FUNCTION,  (size_t) "interact_shock_SPOOFED",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_snufit_bullet",            LVT_FUNCTION,  (size_t) "interact_snufit_bullet_SPOOFED",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_spiny_walking",            LVT_FUNCTION,  (size_t) "interact_spiny_walking_SPOOFED",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_star_or_key",              LVT_FUNCTION,  (size_t) "interact_star_or_key_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_strong_wind",              LVT_FUNCTION,  (size_t) "interact_strong_wind_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_text",                     LVT_FUNCTION,  (size_t) "interact_text_SPOOFED",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_tornado",                  LVT_FUNCTION,  (size_t) "interact_tornado_SPOOFED",                    true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_warp",                     LVT_FUNCTION,  (size_t) "interact_warp_SPOOFED",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_warp_door",                LVT_FUNCTION,  (size_t) "interact_warp_door_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_water_ring",               LVT_FUNCTION,  (size_t) "interact_water_ring_SPOOFED",                 true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "interact_whirlpool",                LVT_FUNCTION,  (size_t) "interact_whirlpool_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "invincTimer",                       LVT_S16,       offsetof(struct MarioState, invincTimer),               false, LOT_NONE,              1, sizeof(s16)                       },
-    { "isSnoring",                         LVT_U8,        offsetof(struct MarioState, isSnoring),                 false, LOT_NONE,              1, sizeof(u8)                        },
-    { "is_anim_at_end",                    LVT_FUNCTION,  (size_t) "is_anim_at_end",                              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "is_anim_past_end",                  LVT_FUNCTION,  (size_t) "is_anim_past_end",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "is_anim_past_frame",                LVT_FUNCTION,  (size_t) "is_anim_past_frame",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "is_crouching",                      LVT_FUNCTION,  (size_t) "mario_is_crouching",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "is_dive_sliding",                   LVT_FUNCTION,  (size_t) "mario_is_dive_sliding",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "is_ground_pound_landing",           LVT_FUNCTION,  (size_t) "mario_is_ground_pound_landing",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "is_in_air_action",                  LVT_FUNCTION,  (size_t) "mario_is_in_air_action",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "is_nearest_state_to_object",        LVT_FUNCTION,  (size_t) "is_nearest_mario_state_to_object",            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "is_player_active",                  LVT_FUNCTION,  (size_t) "is_player_active",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "is_player_in_local_area",           LVT_FUNCTION,  (size_t) "is_player_in_local_area",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "knockbackTimer",                    LVT_S8,        offsetof(struct MarioState, knockbackTimer),            false, LOT_NONE,              1, sizeof(s8)                        },
-    { "landing_step",                      LVT_FUNCTION,  (size_t) "landing_step",                                true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "launch_until_land",                 LVT_FUNCTION,  (size_t) "launch_mario_until_land",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "lava_boost_on_wall",                LVT_FUNCTION,  (size_t) "lava_boost_on_wall",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "let_go_of_ledge",                   LVT_FUNCTION,  (size_t) "let_go_of_ledge",                             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "level_trigger_warp",                LVT_FUNCTION,  (size_t) "level_trigger_warp",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "lose_cap_to_enemy",                 LVT_FUNCTION,  (size_t) "mario_lose_cap_to_enemy",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "marioBodyState",                    LVT_COBJECT_P, offsetof(struct MarioState, marioBodyState),            true,  LOT_MARIOBODYSTATE,    1, sizeof(struct MarioBodyState*)    },
-    { "marioObj",                          LVT_COBJECT_P, offsetof(struct MarioState, marioObj),                  true,  LOT_OBJECT,            1, sizeof(struct Object*)            },
-    { "minimumBoneY",                      LVT_F32,       offsetof(struct MarioState, minimumBoneY),              false, LOT_NONE,              1, sizeof(f32)                       },
-    { "nonInstantWarpPos",                 LVT_COBJECT,   offsetof(struct MarioState, nonInstantWarpPos),         true,  LOT_VEC3F,             1, sizeof(Vec3f)                     },
-    { "numCoins",                          LVT_S16,       offsetof(struct MarioState, numCoins),                  false, LOT_NONE,              1, sizeof(s16)                       },
-    { "numKeys",                           LVT_S8,        offsetof(struct MarioState, numKeys),                   false, LOT_NONE,              1, sizeof(s8)                        },
-    { "numLives",                          LVT_S8,        offsetof(struct MarioState, numLives),                  false, LOT_NONE,              1, sizeof(s8)                        },
-    { "numStars",                          LVT_S16,       offsetof(struct MarioState, numStars),                  false, LOT_NONE,              1, sizeof(s16)                       },
-    { "obj_angle_to_object",               LVT_FUNCTION,  (size_t) "mario_obj_angle_to_object",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "obj_is_ground_pounding_platform",   LVT_FUNCTION,  (size_t) "obj_is_mario_ground_pounding_platform",       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "obj_is_near_to_and_facing",         LVT_FUNCTION,  (size_t) "obj_is_near_to_and_facing_mario",             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "obj_turn_pitch_toward",             LVT_FUNCTION,  (size_t) "obj_turn_pitch_toward_mario",                 true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "particleFlags",                     LVT_U32,       offsetof(struct MarioState, particleFlags),             false, LOT_NONE,              1, sizeof(u32)                       },
-    { "passes_pvp_interaction_checks",     LVT_FUNCTION,  (size_t) "passes_pvp_interaction_checks",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "peakHeight",                        LVT_F32,       offsetof(struct MarioState, peakHeight),                false, LOT_NONE,              1, sizeof(f32)                       },
-    { "perform_air_step",                  LVT_FUNCTION,  (size_t) "perform_air_step",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "perform_ground_step",               LVT_FUNCTION,  (size_t) "perform_ground_step",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "perform_hanging_step",              LVT_FUNCTION,  (size_t) "perform_hanging_step",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "perform_water_full_step",           LVT_FUNCTION,  (size_t) "perform_water_full_step",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "perform_water_step",                LVT_FUNCTION,  (size_t) "perform_water_step",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_action_sound",                 LVT_FUNCTION,  (size_t) "play_mario_action_sound",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_anim_sound",                   LVT_FUNCTION,  (size_t) "play_anim_sound",                             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_character_sound",              LVT_FUNCTION,  (size_t) "play_character_sound",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_character_sound_if_no_flag",   LVT_FUNCTION,  (size_t) "play_character_sound_if_no_flag",             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_character_sound_offset",       LVT_FUNCTION,  (size_t) "play_character_sound_offset",                 true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_climbing_sounds",              LVT_FUNCTION,  (size_t) "play_climbing_sounds",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_far_fall_sound",               LVT_FUNCTION,  (size_t) "play_far_fall_sound",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_flip_sounds",                  LVT_FUNCTION,  (size_t) "play_flip_sounds",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_heavy_landing_sound",          LVT_FUNCTION,  (size_t) "play_mario_heavy_landing_sound",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_heavy_landing_sound_once",     LVT_FUNCTION,  (size_t) "play_mario_heavy_landing_sound_once",         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_jump_sound",                   LVT_FUNCTION,  (size_t) "play_mario_jump_sound",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_knockback_sound",              LVT_FUNCTION,  (size_t) "play_knockback_sound",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_landing_sound",                LVT_FUNCTION,  (size_t) "play_mario_landing_sound",                    true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_landing_sound_once",           LVT_FUNCTION,  (size_t) "play_mario_landing_sound_once",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_sound",                        LVT_FUNCTION,  (size_t) "play_mario_sound",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_sound_and_spawn_particles",    LVT_FUNCTION,  (size_t) "play_sound_and_spawn_particles",              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_sound_if_no_flag",             LVT_FUNCTION,  (size_t) "play_sound_if_no_flag",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "play_step_sound",                   LVT_FUNCTION,  (size_t) "play_step_sound",                             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "playerIndex",                       LVT_U16,       offsetof(struct MarioState, playerIndex),               true,  LOT_NONE,              1, sizeof(u16)                       },
-    { "pop_bubble",                        LVT_FUNCTION,  (size_t) "mario_pop_bubble",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "pos",                               LVT_COBJECT,   offsetof(struct MarioState, pos),                       true,  LOT_VEC3F,             1, sizeof(Vec3f)                     },
-    { "prevAction",                        LVT_U32,       offsetof(struct MarioState, prevAction),                false, LOT_NONE,              1, sizeof(u32)                       },
-    { "prevNumStarsForDialog",             LVT_S16,       offsetof(struct MarioState, prevNumStarsForDialog),     false, LOT_NONE,              1, sizeof(s16)                       },
-    { "push_off_steep_floor",              LVT_FUNCTION,  (size_t) "mario_push_off_steep_floor",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "push_or_sidle_wall",                LVT_FUNCTION,  (size_t) "push_or_sidle_wall",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "queue_rumble_data",                 LVT_FUNCTION,  (size_t) "queue_rumble_data_mario",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "quicksandDepth",                    LVT_F32,       offsetof(struct MarioState, quicksandDepth),            false, LOT_NONE,              1, sizeof(f32)                       },
-    { "quicksand_jump_land_action",        LVT_FUNCTION,  (size_t) "quicksand_jump_land_action",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "ready_to_speak",                    LVT_FUNCTION,  (size_t) "mario_ready_to_speak",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "reset_rumble_timers",               LVT_FUNCTION,  (size_t) "reset_rumble_timers",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "reset_rumble_timers_2",             LVT_FUNCTION,  (size_t) "reset_rumble_timers_2",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "retrieve_cap",                      LVT_FUNCTION,  (size_t) "mario_retrieve_cap",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "return_anim_y_translation",         LVT_FUNCTION,  (size_t) "return_mario_anim_y_translation",             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "riddenObj",                         LVT_COBJECT_P, offsetof(struct MarioState, riddenObj),                 false, LOT_OBJECT,            1, sizeof(struct Object*)            },
-    { "set_action",                        LVT_FUNCTION,  (size_t) "set_mario_action",                            true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_anim_to_frame",                 LVT_FUNCTION,  (size_t) "set_anim_to_frame",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_anim_with_accel",               LVT_FUNCTION,  (size_t) "set_mario_anim_with_accel",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_animation",                     LVT_FUNCTION,  (size_t) "set_mario_animation",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_bubbled",                       LVT_FUNCTION,  (size_t) "mario_set_bubbled",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_character_anim_with_accel",     LVT_FUNCTION,  (size_t) "set_character_anim_with_accel",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_character_animation",           LVT_FUNCTION,  (size_t) "set_character_animation",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_forward_vel",                   LVT_FUNCTION,  (size_t) "mario_set_forward_vel",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_jump_from_landing",             LVT_FUNCTION,  (size_t) "set_jump_from_landing",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_jumping_action",                LVT_FUNCTION,  (size_t) "set_jumping_action",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_particle_flags",                LVT_FUNCTION,  (size_t) "set_mario_particle_flags",                    true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_pole_position",                 LVT_FUNCTION,  (size_t) "set_pole_position",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_steep_jump_action",             LVT_FUNCTION,  (size_t) "set_steep_jump_action",                       true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_swimming_at_surface_particles", LVT_FUNCTION,  (size_t) "set_swimming_at_surface_particles",           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_triple_jump_action",            LVT_FUNCTION,  (size_t) "set_triple_jump_action",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_vel_from_pitch_and_yaw",        LVT_FUNCTION,  (size_t) "set_vel_from_pitch_and_yaw",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_water_plunge_action",           LVT_FUNCTION,  (size_t) "set_water_plunge_action",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "set_y_vel_based_on_fspeed",         LVT_FUNCTION,  (size_t) "set_mario_y_vel_based_on_fspeed",             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "should_begin_sliding",              LVT_FUNCTION,  (size_t) "should_begin_sliding",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "should_get_stuck_in_ground",        LVT_FUNCTION,  (size_t) "should_get_stuck_in_ground",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "should_push_or_pull_door",          LVT_FUNCTION,  (size_t) "should_push_or_pull_door",                    true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "should_start_or_continue_dialog",   LVT_FUNCTION,  (size_t) "should_start_or_continue_dialog",             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "skipWarpInteractionsTimer",         LVT_U8,        offsetof(struct MarioState, skipWarpInteractionsTimer), false, LOT_NONE,              1, sizeof(u8)                        },
-    { "slideVelX",                         LVT_F32,       offsetof(struct MarioState, slideVelX),                 false, LOT_NONE,              1, sizeof(f32)                       },
-    { "slideVelZ",                         LVT_F32,       offsetof(struct MarioState, slideVelZ),                 false, LOT_NONE,              1, sizeof(f32)                       },
-    { "slideYaw",                          LVT_S16,       offsetof(struct MarioState, slideYaw),                  false, LOT_NONE,              1, sizeof(s16)                       },
-    { "slide_bonk",                        LVT_FUNCTION,  (size_t) "slide_bonk",                                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "spawnInfo",                         LVT_COBJECT_P, offsetof(struct MarioState, spawnInfo),                 false, LOT_SPAWNINFO,         1, sizeof(struct SpawnInfo*)         },
-    { "specialTripleJump",                 LVT_U8,        offsetof(struct MarioState, specialTripleJump),         false, LOT_NONE,              1, sizeof(u8)                        },
-    { "splineKeyframe",                    LVT_COBJECT_P, offsetof(struct MarioState, splineKeyframe),            false, LOT_VEC4S,             1, sizeof(Vec4s*)                    },
-    { "splineKeyframeFraction",            LVT_F32,       offsetof(struct MarioState, splineKeyframeFraction),    false, LOT_NONE,              1, sizeof(f32)                       },
-    { "splineState",                       LVT_S32,       offsetof(struct MarioState, splineState),               false, LOT_NONE,              1, sizeof(s32)                       },
-    { "spline_get_weights",                LVT_FUNCTION,  (size_t) "spline_get_weights",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "squishTimer",                       LVT_U8,        offsetof(struct MarioState, squishTimer),               false, LOT_NONE,              1, sizeof(u8)                        },
-    { "stationary_ground_step",            LVT_FUNCTION,  (size_t) "stationary_ground_step",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "statusForCamera",                   LVT_COBJECT_P, offsetof(struct MarioState, statusForCamera),           true,  LOT_PLAYERCAMERASTATE, 1, sizeof(struct PlayerCameraState*) },
-    { "stomach_slide_action",              LVT_FUNCTION,  (size_t) "stomach_slide_action",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "stop_and_set_height_to_floor",      LVT_FUNCTION,  (size_t) "stop_and_set_height_to_floor",                true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "stop_riding_and_holding",           LVT_FUNCTION,  (size_t) "mario_stop_riding_and_holding",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "stop_riding_object",                LVT_FUNCTION,  (size_t) "mario_stop_riding_object",                    true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "stopping_step",                     LVT_FUNCTION,  (size_t) "stopping_step",                               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "stuck_in_ground_handler",           LVT_FUNCTION,  (size_t) "stuck_in_ground_handler",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "take_damage_and_knock_back",        LVT_FUNCTION,  (size_t) "take_damage_and_knock_back",                  true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "terrainSoundAddend",                LVT_U32,       offsetof(struct MarioState, terrainSoundAddend),        false, LOT_NONE,              1, sizeof(u32)                       },
-    { "throw_held_object",                 LVT_FUNCTION,  (size_t) "mario_throw_held_object",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "tilt_body_butt_slide",              LVT_FUNCTION,  (size_t) "tilt_body_butt_slide",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "tilt_body_ground_shell",            LVT_FUNCTION,  (size_t) "tilt_body_ground_shell",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "tilt_body_running",                 LVT_FUNCTION,  (size_t) "tilt_body_running",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "tilt_body_walking",                 LVT_FUNCTION,  (size_t) "tilt_body_walking",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "transition_submerged_to_walking",   LVT_FUNCTION,  (size_t) "transition_submerged_to_walking",             true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "twirlYaw",                          LVT_S16,       offsetof(struct MarioState, twirlYaw),                  false, LOT_NONE,              1, sizeof(s16)                       },
-    { "unkB0",                             LVT_S16,       offsetof(struct MarioState, unkB0),                     false, LOT_NONE,              1, sizeof(s16)                       },
-    { "unkC4",                             LVT_F32,       offsetof(struct MarioState, unkC4),                     false, LOT_NONE,              1, sizeof(f32)                       },
-    { "update_air_with_turn",              LVT_FUNCTION,  (size_t) "update_air_with_turn",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_air_without_turn",           LVT_FUNCTION,  (size_t) "update_air_without_turn",                     true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_character_anim_offset",      LVT_FUNCTION,  (size_t) "update_character_anim_offset",                true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_decelerating_speed",         LVT_FUNCTION,  (size_t) "update_decelerating_speed",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_flying",                     LVT_FUNCTION,  (size_t) "update_flying",                               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_flying_pitch",               LVT_FUNCTION,  (size_t) "update_flying_pitch",                         true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_flying_yaw",                 LVT_FUNCTION,  (size_t) "update_flying_yaw",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_hang_moving",                LVT_FUNCTION,  (size_t) "update_hang_moving",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_hang_stationary",            LVT_FUNCTION,  (size_t) "update_hang_stationary",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_lava_boost_or_twirling",     LVT_FUNCTION,  (size_t) "update_lava_boost_or_twirling",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_ledge_climb",                LVT_FUNCTION,  (size_t) "update_ledge_climb",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_ledge_climb_camera",         LVT_FUNCTION,  (size_t) "update_ledge_climb_camera",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_moving_sand",                LVT_FUNCTION,  (size_t) "mario_update_moving_sand",                    true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_pos_for_anim",               LVT_FUNCTION,  (size_t) "update_mario_pos_for_anim",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_punch_sequence",             LVT_FUNCTION,  (size_t) "mario_update_punch_sequence",                 true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_quicksand",                  LVT_FUNCTION,  (size_t) "mario_update_quicksand",                      true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_shell_speed",                LVT_FUNCTION,  (size_t) "update_shell_speed",                          true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_sliding",                    LVT_FUNCTION,  (size_t) "update_sliding",                              true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_sliding_angle",              LVT_FUNCTION,  (size_t) "update_sliding_angle",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_sound_and_camera",           LVT_FUNCTION,  (size_t) "update_mario_sound_and_camera",               true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_walking_speed",              LVT_FUNCTION,  (size_t) "update_walking_speed",                        true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_wall",                       LVT_FUNCTION,  (size_t) "mario_update_wall",                           true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "update_windy_ground",               LVT_FUNCTION,  (size_t) "mario_update_windy_ground",                   true,  LOT_NONE,              1, sizeof(const char *)              },
-    { "usedObj",                           LVT_COBJECT_P, offsetof(struct MarioState, usedObj),                   false, LOT_OBJECT,            1, sizeof(struct Object*)            },
-    { "vel",                               LVT_COBJECT,   offsetof(struct MarioState, vel),                       true,  LOT_VEC3F,             1, sizeof(Vec3f)                     },
-    { "wall",                              LVT_COBJECT_P, offsetof(struct MarioState, wall),                      false, LOT_SURFACE,           1, sizeof(struct Surface*)           },
-    { "wallKickTimer",                     LVT_U8,        offsetof(struct MarioState, wallKickTimer),             false, LOT_NONE,              1, sizeof(u8)                        },
-    { "wallNormal",                        LVT_COBJECT,   offsetof(struct MarioState, wallNormal),                true,  LOT_VEC3F,             1, sizeof(Vec3f)                     },
-    { "wasNetworkVisible",                 LVT_U8,        offsetof(struct MarioState, wasNetworkVisible),         false, LOT_NONE,              1, sizeof(u8)                        },
-    { "waterLevel",                        LVT_S16,       offsetof(struct MarioState, waterLevel),                false, LOT_NONE,              1, sizeof(s16)                       },
+    { "action",                            LVT_U32,       offsetof(struct MarioState, action),                      false, LOT_NONE,              1, sizeof(u32)                       },
+    { "actionArg",                         LVT_U32,       offsetof(struct MarioState, actionArg),                   false, LOT_NONE,              1, sizeof(u32)                       },
+    { "actionState",                       LVT_U16,       offsetof(struct MarioState, actionState),                 false, LOT_NONE,              1, sizeof(u16)                       },
+    { "actionTimer",                       LVT_U16,       offsetof(struct MarioState, actionTimer),                 false, LOT_NONE,              1, sizeof(u16)                       },
+    { "add_tree_leaf_particles",           LVT_FUNCTION,  (size_t) "add_tree_leaf_particles",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "adjust_sound_for_speed",            LVT_FUNCTION,  (size_t) "adjust_sound_for_speed",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "align_with_floor",                  LVT_FUNCTION,  (size_t) "align_with_floor",                              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "analog_stick_held_back",            LVT_FUNCTION,  (size_t) "analog_stick_held_back_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "angleVel",                          LVT_COBJECT,   offsetof(struct MarioState, angleVel),                    true,  LOT_VEC3S,             1, sizeof(Vec3s)                     },
+    { "anim_and_audio_for_heavy_walk",     LVT_FUNCTION,  (size_t) "anim_and_audio_for_heavy_walk",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "anim_and_audio_for_hold_walk",      LVT_FUNCTION,  (size_t) "anim_and_audio_for_hold_walk",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "anim_and_audio_for_walk",           LVT_FUNCTION,  (size_t) "anim_and_audio_for_walk",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "anim_spline_init",                  LVT_FUNCTION,  (size_t) "anim_spline_init",                              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "anim_spline_poll",                  LVT_FUNCTION,  (size_t) "anim_spline_poll_SPOOFED",                      true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "animated_stationary_ground_step",   LVT_FUNCTION,  (size_t) "animated_stationary_ground_step",               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "animation",                         LVT_COBJECT_P, offsetof(struct MarioState, animation),                   false, LOT_MARIOANIMATION,    1, sizeof(struct MarioAnimation*)    },
+    { "apply_landing_accel",               LVT_FUNCTION,  (size_t) "apply_landing_accel_SPOOFED",                   true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "apply_slope_accel",                 LVT_FUNCTION,  (size_t) "apply_slope_accel",                             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "apply_slope_decel",                 LVT_FUNCTION,  (size_t) "apply_slope_decel_SPOOFED",                     true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "apply_water_current",               LVT_FUNCTION,  (size_t) "apply_water_current",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "area",                              LVT_COBJECT_P, offsetof(struct MarioState, area),                        true,  LOT_AREA,              1, sizeof(struct Area*)              },
+    { "begin_braking_action",              LVT_FUNCTION,  (size_t) "begin_braking_action_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "begin_walking_action",              LVT_FUNCTION,  (size_t) "begin_walking_action_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "blow_off_cap",                      LVT_FUNCTION,  (size_t) "mario_blow_off_cap",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "bonk_reflection",                   LVT_FUNCTION,  (size_t) "mario_bonk_reflection",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "bounceSquishTimer",                 LVT_U8,        offsetof(struct MarioState, bounceSquishTimer),           false, LOT_NONE,              1, sizeof(u8)                        },
+    { "bubbleObj",                         LVT_COBJECT_P, offsetof(struct MarioState, bubbleObj),                   false, LOT_OBJECT,            1, sizeof(struct Object*)            },
+    { "can_bubble",                        LVT_FUNCTION,  (size_t) "mario_can_bubble",                              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "cap",                               LVT_U32,       offsetof(struct MarioState, cap),                         false, LOT_NONE,              1, sizeof(u32)                       },
+    { "capTimer",                          LVT_U16,       offsetof(struct MarioState, capTimer),                    false, LOT_NONE,              1, sizeof(u16)                       },
+    { "ceil",                              LVT_COBJECT_P, offsetof(struct MarioState, ceil),                        false, LOT_SURFACE,           1, sizeof(struct Surface*)           },
+    { "ceilHeight",                        LVT_F32,       offsetof(struct MarioState, ceilHeight),                  false, LOT_NONE,              1, sizeof(f32)                       },
+    { "character",                         LVT_COBJECT_P, offsetof(struct MarioState, character),                   false, LOT_CHARACTER,         1, sizeof(struct Character*)         },
+    { "check_common_action_exits",         LVT_FUNCTION,  (size_t) "check_common_action_exits_SPOOFED",             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_common_airborne_cancels",     LVT_FUNCTION,  (size_t) "check_common_airborne_cancels_SPOOFED",         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_common_automatic_cancels",    LVT_FUNCTION,  (size_t) "check_common_automatic_cancels_SPOOFED",        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_common_hold_action_exits",    LVT_FUNCTION,  (size_t) "check_common_hold_action_exits_SPOOFED",        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_common_hold_idle_cancels",    LVT_FUNCTION,  (size_t) "check_common_hold_idle_cancels_SPOOFED",        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_common_idle_cancels",         LVT_FUNCTION,  (size_t) "check_common_idle_cancels_SPOOFED",             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_common_landing_cancels",      LVT_FUNCTION,  (size_t) "check_common_landing_cancels_SPOOFED",          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_common_moving_cancels",       LVT_FUNCTION,  (size_t) "check_common_moving_cancels_SPOOFED",           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_common_object_cancels",       LVT_FUNCTION,  (size_t) "check_common_object_cancels_SPOOFED",           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_common_stationary_cancels",   LVT_FUNCTION,  (size_t) "check_common_stationary_cancels_SPOOFED",       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_fall_damage",                 LVT_FUNCTION,  (size_t) "check_fall_damage_SPOOFED",                     true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_fall_damage_or_get_stuck",    LVT_FUNCTION,  (size_t) "check_fall_damage_or_get_stuck_SPOOFED",        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_ground_dive_or_punch",        LVT_FUNCTION,  (size_t) "check_ground_dive_or_punch_SPOOFED",            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_horizontal_wind",             LVT_FUNCTION,  (size_t) "check_horizontal_wind_SPOOFED",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_kick_or_dive_in_air",         LVT_FUNCTION,  (size_t) "check_kick_or_dive_in_air_SPOOFED",             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_ledge_climb_down",            LVT_FUNCTION,  (size_t) "check_ledge_climb_down_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_object_grab",                 LVT_FUNCTION,  (size_t) "mario_check_object_grab_SPOOFED",               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "check_wall_kick",                   LVT_FUNCTION,  (size_t) "check_wall_kick_SPOOFED",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "climb_up_ledge",                    LVT_FUNCTION,  (size_t) "climb_up_ledge",                                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "collidedObjInteractTypes",          LVT_U32,       offsetof(struct MarioState, collidedObjInteractTypes),    false, LOT_NONE,              1, sizeof(u32)                       },
+    { "common_air_action_step",            LVT_FUNCTION,  (size_t) "common_air_action_step_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "common_air_knockback_step",         LVT_FUNCTION,  (size_t) "common_air_knockback_step_SPOOFED",             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "common_death_handler",              LVT_FUNCTION,  (size_t) "common_death_handler",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "common_ground_knockback_action",    LVT_FUNCTION,  (size_t) "common_ground_knockback_action_SPOOFED",        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "common_landing_action",             LVT_FUNCTION,  (size_t) "common_landing_action_SPOOFED",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "common_slide_action",               LVT_FUNCTION,  (size_t) "common_slide_action",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "common_slide_action_with_jump",     LVT_FUNCTION,  (size_t) "common_slide_action_with_jump_SPOOFED",         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "controller",                        LVT_COBJECT_P, offsetof(struct MarioState, controller),                  true,  LOT_CONTROLLER,        1, sizeof(struct Controller*)        },
+    { "curAnimOffset",                     LVT_F32,       offsetof(struct MarioState, curAnimOffset),               false, LOT_NONE,              1, sizeof(f32)                       },
+    { "cur_obj_can_activate_textbox",      LVT_FUNCTION,  (size_t) "cur_obj_can_mario_activate_textbox_SPOOFED",    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "cur_obj_can_activate_textbox_2",    LVT_FUNCTION,  (size_t) "cur_obj_can_mario_activate_textbox_2_SPOOFED",  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "cur_obj_end_dialog",                LVT_FUNCTION,  (size_t) "cur_obj_end_dialog",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "cur_obj_set_vel_from_vel",          LVT_FUNCTION,  (size_t) "cur_obj_set_vel_from_mario_vel",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "cur_obj_spawn_loot_coin_at_pos",    LVT_FUNCTION,  (size_t) "cur_obj_spawn_loot_coin_at_mario_pos",          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "currentRoom",                       LVT_S16,       offsetof(struct MarioState, currentRoom),                 false, LOT_NONE,              1, sizeof(s16)                       },
+    { "cutscene_put_cap_on",               LVT_FUNCTION,  (size_t) "cutscene_put_cap_on",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "cutscene_take_cap_off",             LVT_FUNCTION,  (size_t) "cutscene_take_cap_off",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "determine_interaction",             LVT_FUNCTION,  (size_t) "determine_interaction",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "dialogId",                          LVT_S32,       offsetof(struct MarioState, dialogId),                    true,  LOT_NONE,              1, sizeof(s32)                       },
+    { "does_have_blown_cap",               LVT_FUNCTION,  (size_t) "does_mario_have_blown_cap",                     true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "does_have_normal_cap_on_head",      LVT_FUNCTION,  (size_t) "does_mario_have_normal_cap_on_head_SPOOFED",    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "doubleJumpTimer",                   LVT_U8,        offsetof(struct MarioState, doubleJumpTimer),             false, LOT_NONE,              1, sizeof(u8)                        },
+    { "drop_and_set_action",               LVT_FUNCTION,  (size_t) "drop_and_set_mario_action_SPOOFED",             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "drop_held_object",                  LVT_FUNCTION,  (size_t) "mario_drop_held_object",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "execute_airborne_action",           LVT_FUNCTION,  (size_t) "mario_execute_airborne_action_SPOOFED",         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "execute_automatic_action",          LVT_FUNCTION,  (size_t) "mario_execute_automatic_action_SPOOFED",        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "execute_cutscene_action",           LVT_FUNCTION,  (size_t) "mario_execute_cutscene_action_SPOOFED",         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "execute_moving_action",             LVT_FUNCTION,  (size_t) "mario_execute_moving_action_SPOOFED",           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "execute_object_action",             LVT_FUNCTION,  (size_t) "mario_execute_object_action_SPOOFED",           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "execute_stationary_action",         LVT_FUNCTION,  (size_t) "mario_execute_stationary_action_SPOOFED",       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "execute_submerged_action",          LVT_FUNCTION,  (size_t) "mario_execute_submerged_action_SPOOFED",        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "exit_palette_editor",               LVT_FUNCTION,  (size_t) "mario_exit_palette_editor_SPOOFED",             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "faceAngle",                         LVT_COBJECT,   offsetof(struct MarioState, faceAngle),                   true,  LOT_VEC3S,             1, sizeof(Vec3s)                     },
+    { "facing_downhill",                   LVT_FUNCTION,  (size_t) "mario_facing_downhill_SPOOFED",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "fadeWarpOpacity",                   LVT_U8,        offsetof(struct MarioState, fadeWarpOpacity),             false, LOT_NONE,              1, sizeof(u8)                        },
+    { "find_floor_height_relative_polar",  LVT_FUNCTION,  (size_t) "find_floor_height_relative_polar",              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "find_floor_slope",                  LVT_FUNCTION,  (size_t) "find_floor_slope",                              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "first_person_check_cancels",        LVT_FUNCTION,  (size_t) "first_person_check_cancels",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "flags",                             LVT_U32,       offsetof(struct MarioState, flags),                       false, LOT_NONE,              1, sizeof(u32)                       },
+    { "float_surface_gfx",                 LVT_FUNCTION,  (size_t) "float_surface_gfx",                             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "floor",                             LVT_COBJECT_P, offsetof(struct MarioState, floor),                       false, LOT_SURFACE,           1, sizeof(struct Surface*)           },
+    { "floorAngle",                        LVT_S16,       offsetof(struct MarioState, floorAngle),                  false, LOT_NONE,              1, sizeof(s16)                       },
+    { "floorHeight",                       LVT_F32,       offsetof(struct MarioState, floorHeight),                 false, LOT_NONE,              1, sizeof(f32)                       },
+    { "floor_is_slippery",                 LVT_FUNCTION,  (size_t) "mario_floor_is_slippery_SPOOFED",               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "floor_is_slope",                    LVT_FUNCTION,  (size_t) "mario_floor_is_slope_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "floor_is_steep",                    LVT_FUNCTION,  (size_t) "mario_floor_is_steep_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "force_idle_state",                  LVT_FUNCTION,  (size_t) "force_idle_state_SPOOFED",                      true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "forwardVel",                        LVT_F32,       offsetof(struct MarioState, forwardVel),                  false, LOT_NONE,              1, sizeof(f32)                       },
+    { "framesSinceA",                      LVT_U8,        offsetof(struct MarioState, framesSinceA),                false, LOT_NONE,              1, sizeof(u8)                        },
+    { "framesSinceB",                      LVT_U8,        offsetof(struct MarioState, framesSinceB),                false, LOT_NONE,              1, sizeof(u8)                        },
+    { "freeze",                            LVT_U8,        offsetof(struct MarioState, freeze),                      false, LOT_NONE,              1, sizeof(u8)                        },
+    { "general_star_dance_handler",        LVT_FUNCTION,  (size_t) "general_star_dance_handler",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_anim_part_pos",                 LVT_FUNCTION,  (size_t) "get_mario_anim_part_pos",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_anim_part_rot",                 LVT_FUNCTION,  (size_t) "get_mario_anim_part_rot",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_character",                     LVT_FUNCTION,  (size_t) "get_character",                                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_character_anim",                LVT_FUNCTION,  (size_t) "get_character_anim",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_character_anim_offset",         LVT_FUNCTION,  (size_t) "get_character_anim_offset",                     true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_collided_object",               LVT_FUNCTION,  (size_t) "mario_get_collided_object",                     true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_floor_class",                   LVT_FUNCTION,  (size_t) "mario_get_floor_class",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_hand_foot_pos_x",               LVT_FUNCTION,  (size_t) "get_hand_foot_pos_x",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_hand_foot_pos_y",               LVT_FUNCTION,  (size_t) "get_hand_foot_pos_y",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_hand_foot_pos_z",               LVT_FUNCTION,  (size_t) "get_hand_foot_pos_z",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_star_collection_dialog",        LVT_FUNCTION,  (size_t) "get_star_collection_dialog",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "get_terrain_sound_addend",          LVT_FUNCTION,  (size_t) "mario_get_terrain_sound_addend",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "grab_used_object",                  LVT_FUNCTION,  (size_t) "mario_grab_used_object",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "handle_save_menu",                  LVT_FUNCTION,  (size_t) "handle_save_menu",                              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "healCounter",                       LVT_U8,        offsetof(struct MarioState, healCounter),                 false, LOT_NONE,              1, sizeof(u8)                        },
+    { "health",                            LVT_S16,       offsetof(struct MarioState, health),                      false, LOT_NONE,              1, sizeof(s16)                       },
+    { "heldByObj",                         LVT_COBJECT_P, offsetof(struct MarioState, heldByObj),                   false, LOT_OBJECT,            1, sizeof(struct Object*)            },
+    { "heldObj",                           LVT_COBJECT_P, offsetof(struct MarioState, heldObj),                     false, LOT_OBJECT,            1, sizeof(struct Object*)            },
+    { "hurtCounter",                       LVT_U8,        offsetof(struct MarioState, hurtCounter),                 false, LOT_NONE,              1, sizeof(u8)                        },
+    { "hurt_and_set_action",               LVT_FUNCTION,  (size_t) "hurt_and_set_mario_action_SPOOFED",             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "init_single",                       LVT_FUNCTION,  (size_t) "init_single_mario",                             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "input",                             LVT_U16,       offsetof(struct MarioState, input),                       false, LOT_NONE,              1, sizeof(u16)                       },
+    { "intendedMag",                       LVT_F32,       offsetof(struct MarioState, intendedMag),                 false, LOT_NONE,              1, sizeof(f32)                       },
+    { "intendedYaw",                       LVT_S16,       offsetof(struct MarioState, intendedYaw),                 false, LOT_NONE,              1, sizeof(s16)                       },
+    { "interactObj",                       LVT_COBJECT_P, offsetof(struct MarioState, interactObj),                 false, LOT_OBJECT,            1, sizeof(struct Object*)            },
+    { "interact_bbh_entrance",             LVT_FUNCTION,  (size_t) "interact_bbh_entrance_SPOOFED",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_bounce_top",               LVT_FUNCTION,  (size_t) "interact_bounce_top_SPOOFED",                   true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_breakable",                LVT_FUNCTION,  (size_t) "interact_breakable_SPOOFED",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_bully",                    LVT_FUNCTION,  (size_t) "interact_bully_SPOOFED",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_cannon_base",              LVT_FUNCTION,  (size_t) "interact_cannon_base_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_cap",                      LVT_FUNCTION,  (size_t) "interact_cap_SPOOFED",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_clam_or_bubba",            LVT_FUNCTION,  (size_t) "interact_clam_or_bubba_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_coin",                     LVT_FUNCTION,  (size_t) "interact_coin_SPOOFED",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_damage",                   LVT_FUNCTION,  (size_t) "interact_damage_SPOOFED",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_door",                     LVT_FUNCTION,  (size_t) "interact_door_SPOOFED",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_flame",                    LVT_FUNCTION,  (size_t) "interact_flame_SPOOFED",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_grabbable",                LVT_FUNCTION,  (size_t) "interact_grabbable_SPOOFED",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_hit_from_below",           LVT_FUNCTION,  (size_t) "interact_hit_from_below_SPOOFED",               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_hoot",                     LVT_FUNCTION,  (size_t) "interact_hoot_SPOOFED",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_igloo_barrier",            LVT_FUNCTION,  (size_t) "interact_igloo_barrier_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_koopa_shell",              LVT_FUNCTION,  (size_t) "interact_koopa_shell_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_mr_blizzard",              LVT_FUNCTION,  (size_t) "interact_mr_blizzard_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_player",                   LVT_FUNCTION,  (size_t) "interact_player_SPOOFED",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_pole",                     LVT_FUNCTION,  (size_t) "interact_pole_SPOOFED",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_shock",                    LVT_FUNCTION,  (size_t) "interact_shock_SPOOFED",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_snufit_bullet",            LVT_FUNCTION,  (size_t) "interact_snufit_bullet_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_spiny_walking",            LVT_FUNCTION,  (size_t) "interact_spiny_walking_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_star_or_key",              LVT_FUNCTION,  (size_t) "interact_star_or_key_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_strong_wind",              LVT_FUNCTION,  (size_t) "interact_strong_wind_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_text",                     LVT_FUNCTION,  (size_t) "interact_text_SPOOFED",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_tornado",                  LVT_FUNCTION,  (size_t) "interact_tornado_SPOOFED",                      true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_warp",                     LVT_FUNCTION,  (size_t) "interact_warp_SPOOFED",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_warp_door",                LVT_FUNCTION,  (size_t) "interact_warp_door_SPOOFED",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_water_ring",               LVT_FUNCTION,  (size_t) "interact_water_ring_SPOOFED",                   true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "interact_whirlpool",                LVT_FUNCTION,  (size_t) "interact_whirlpool_SPOOFED",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "invincTimer",                       LVT_S16,       offsetof(struct MarioState, invincTimer),                 false, LOT_NONE,              1, sizeof(s16)                       },
+    { "isSnoring",                         LVT_U8,        offsetof(struct MarioState, isSnoring),                   false, LOT_NONE,              1, sizeof(u8)                        },
+    { "is_anim_at_end",                    LVT_FUNCTION,  (size_t) "is_anim_at_end_SPOOFED",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "is_anim_past_end",                  LVT_FUNCTION,  (size_t) "is_anim_past_end_SPOOFED",                      true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "is_anim_past_frame",                LVT_FUNCTION,  (size_t) "is_anim_past_frame_SPOOFED",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "is_crouching",                      LVT_FUNCTION,  (size_t) "mario_is_crouching",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "is_dive_sliding",                   LVT_FUNCTION,  (size_t) "mario_is_dive_sliding_SPOOFED",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "is_ground_pound_landing",           LVT_FUNCTION,  (size_t) "mario_is_ground_pound_landing",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "is_in_air_action",                  LVT_FUNCTION,  (size_t) "mario_is_in_air_action_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "is_nearest_state_to_object",        LVT_FUNCTION,  (size_t) "is_nearest_mario_state_to_object_SPOOFED",      true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "is_player_active",                  LVT_FUNCTION,  (size_t) "is_player_active_SPOOFED",                      true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "is_player_in_local_area",           LVT_FUNCTION,  (size_t) "is_player_in_local_area_SPOOFED",               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "knockbackTimer",                    LVT_S8,        offsetof(struct MarioState, knockbackTimer),              false, LOT_NONE,              1, sizeof(s8)                        },
+    { "landing_step",                      LVT_FUNCTION,  (size_t) "landing_step_SPOOFED",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "launch_until_land",                 LVT_FUNCTION,  (size_t) "launch_mario_until_land",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "lava_boost_on_wall",                LVT_FUNCTION,  (size_t) "lava_boost_on_wall_SPOOFED",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "let_go_of_ledge",                   LVT_FUNCTION,  (size_t) "let_go_of_ledge_SPOOFED",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "level_trigger_warp",                LVT_FUNCTION,  (size_t) "level_trigger_warp",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "lose_cap_to_enemy",                 LVT_FUNCTION,  (size_t) "mario_lose_cap_to_enemy_SPOOFED",               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "marioBodyState",                    LVT_COBJECT_P, offsetof(struct MarioState, marioBodyState),              true,  LOT_MARIOBODYSTATE,    1, sizeof(struct MarioBodyState*)    },
+    { "marioObj",                          LVT_COBJECT_P, offsetof(struct MarioState, marioObj),                    true,  LOT_OBJECT,            1, sizeof(struct Object*)            },
+    { "minimumBoneY",                      LVT_F32,       offsetof(struct MarioState, minimumBoneY),                false, LOT_NONE,              1, sizeof(f32)                       },
+    { "nonInstantWarpPos",                 LVT_COBJECT,   offsetof(struct MarioState, nonInstantWarpPos),           true,  LOT_VEC3F,             1, sizeof(Vec3f)                     },
+    { "numCoins",                          LVT_S16,       offsetof(struct MarioState, numCoins),                    false, LOT_NONE,              1, sizeof(s16)                       },
+    { "numKeys",                           LVT_S8,        offsetof(struct MarioState, numKeys),                     false, LOT_NONE,              1, sizeof(s8)                        },
+    { "numLives",                          LVT_S8,        offsetof(struct MarioState, numLives),                    false, LOT_NONE,              1, sizeof(s8)                        },
+    { "numStars",                          LVT_S16,       offsetof(struct MarioState, numStars),                    false, LOT_NONE,              1, sizeof(s16)                       },
+    { "obj_angle_to_object",               LVT_FUNCTION,  (size_t) "mario_obj_angle_to_object",                     true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "obj_is_ground_pounding_platform",   LVT_FUNCTION,  (size_t) "obj_is_mario_ground_pounding_platform_SPOOFED", true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "obj_is_near_to_and_facing",         LVT_FUNCTION,  (size_t) "obj_is_near_to_and_facing_mario_SPOOFED",       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "obj_turn_pitch_toward",             LVT_FUNCTION,  (size_t) "obj_turn_pitch_toward_mario",                   true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "particleFlags",                     LVT_U32,       offsetof(struct MarioState, particleFlags),               false, LOT_NONE,              1, sizeof(u32)                       },
+    { "passes_pvp_interaction_checks",     LVT_FUNCTION,  (size_t) "passes_pvp_interaction_checks_SPOOFED",         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "peakHeight",                        LVT_F32,       offsetof(struct MarioState, peakHeight),                  false, LOT_NONE,              1, sizeof(f32)                       },
+    { "perform_air_step",                  LVT_FUNCTION,  (size_t) "perform_air_step",                              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "perform_ground_step",               LVT_FUNCTION,  (size_t) "perform_ground_step",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "perform_hanging_step",              LVT_FUNCTION,  (size_t) "perform_hanging_step",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "perform_water_full_step",           LVT_FUNCTION,  (size_t) "perform_water_full_step",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "perform_water_step",                LVT_FUNCTION,  (size_t) "perform_water_step",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_action_sound",                 LVT_FUNCTION,  (size_t) "play_mario_action_sound",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_anim_sound",                   LVT_FUNCTION,  (size_t) "play_anim_sound",                               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_character_sound",              LVT_FUNCTION,  (size_t) "play_character_sound",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_character_sound_if_no_flag",   LVT_FUNCTION,  (size_t) "play_character_sound_if_no_flag",               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_character_sound_offset",       LVT_FUNCTION,  (size_t) "play_character_sound_offset",                   true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_climbing_sounds",              LVT_FUNCTION,  (size_t) "play_climbing_sounds",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_far_fall_sound",               LVT_FUNCTION,  (size_t) "play_far_fall_sound",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_flip_sounds",                  LVT_FUNCTION,  (size_t) "play_flip_sounds",                              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_heavy_landing_sound",          LVT_FUNCTION,  (size_t) "play_mario_heavy_landing_sound",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_heavy_landing_sound_once",     LVT_FUNCTION,  (size_t) "play_mario_heavy_landing_sound_once",           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_jump_sound",                   LVT_FUNCTION,  (size_t) "play_mario_jump_sound",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_knockback_sound",              LVT_FUNCTION,  (size_t) "play_knockback_sound",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_landing_sound",                LVT_FUNCTION,  (size_t) "play_mario_landing_sound",                      true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_landing_sound_once",           LVT_FUNCTION,  (size_t) "play_mario_landing_sound_once",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_sound",                        LVT_FUNCTION,  (size_t) "play_mario_sound",                              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_sound_and_spawn_particles",    LVT_FUNCTION,  (size_t) "play_sound_and_spawn_particles",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_sound_if_no_flag",             LVT_FUNCTION,  (size_t) "play_sound_if_no_flag",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "play_step_sound",                   LVT_FUNCTION,  (size_t) "play_step_sound",                               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "playerIndex",                       LVT_U16,       offsetof(struct MarioState, playerIndex),                 true,  LOT_NONE,              1, sizeof(u16)                       },
+    { "pop_bubble",                        LVT_FUNCTION,  (size_t) "mario_pop_bubble",                              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "pos",                               LVT_COBJECT,   offsetof(struct MarioState, pos),                         true,  LOT_VEC3F,             1, sizeof(Vec3f)                     },
+    { "prevAction",                        LVT_U32,       offsetof(struct MarioState, prevAction),                  false, LOT_NONE,              1, sizeof(u32)                       },
+    { "prevNumStarsForDialog",             LVT_S16,       offsetof(struct MarioState, prevNumStarsForDialog),       false, LOT_NONE,              1, sizeof(s16)                       },
+    { "push_off_steep_floor",              LVT_FUNCTION,  (size_t) "mario_push_off_steep_floor_SPOOFED",            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "push_or_sidle_wall",                LVT_FUNCTION,  (size_t) "push_or_sidle_wall",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "queue_rumble_data",                 LVT_FUNCTION,  (size_t) "queue_rumble_data_mario",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "quicksandDepth",                    LVT_F32,       offsetof(struct MarioState, quicksandDepth),              false, LOT_NONE,              1, sizeof(f32)                       },
+    { "quicksand_jump_land_action",        LVT_FUNCTION,  (size_t) "quicksand_jump_land_action",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "ready_to_speak",                    LVT_FUNCTION,  (size_t) "mario_ready_to_speak_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "reset_rumble_timers",               LVT_FUNCTION,  (size_t) "reset_rumble_timers",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "reset_rumble_timers_2",             LVT_FUNCTION,  (size_t) "reset_rumble_timers_2",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "retrieve_cap",                      LVT_FUNCTION,  (size_t) "mario_retrieve_cap",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "return_anim_y_translation",         LVT_FUNCTION,  (size_t) "return_mario_anim_y_translation",               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "riddenObj",                         LVT_COBJECT_P, offsetof(struct MarioState, riddenObj),                   false, LOT_OBJECT,            1, sizeof(struct Object*)            },
+    { "set_action",                        LVT_FUNCTION,  (size_t) "set_mario_action_SPOOFED",                      true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_anim_to_frame",                 LVT_FUNCTION,  (size_t) "set_anim_to_frame",                             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_anim_with_accel",               LVT_FUNCTION,  (size_t) "set_mario_anim_with_accel",                     true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_animation",                     LVT_FUNCTION,  (size_t) "set_mario_animation",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_bubbled",                       LVT_FUNCTION,  (size_t) "mario_set_bubbled",                             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_character_anim_with_accel",     LVT_FUNCTION,  (size_t) "set_character_anim_with_accel",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_character_animation",           LVT_FUNCTION,  (size_t) "set_character_animation",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_forward_vel",                   LVT_FUNCTION,  (size_t) "mario_set_forward_vel",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_jump_from_landing",             LVT_FUNCTION,  (size_t) "set_jump_from_landing_SPOOFED",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_jumping_action",                LVT_FUNCTION,  (size_t) "set_jumping_action_SPOOFED",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_particle_flags",                LVT_FUNCTION,  (size_t) "set_mario_particle_flags",                      true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_pole_position",                 LVT_FUNCTION,  (size_t) "set_pole_position",                             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_steep_jump_action",             LVT_FUNCTION,  (size_t) "set_steep_jump_action",                         true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_swimming_at_surface_particles", LVT_FUNCTION,  (size_t) "set_swimming_at_surface_particles",             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_triple_jump_action",            LVT_FUNCTION,  (size_t) "set_triple_jump_action_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_vel_from_pitch_and_yaw",        LVT_FUNCTION,  (size_t) "set_vel_from_pitch_and_yaw",                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_water_plunge_action",           LVT_FUNCTION,  (size_t) "set_water_plunge_action_SPOOFED",               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "set_y_vel_based_on_fspeed",         LVT_FUNCTION,  (size_t) "set_mario_y_vel_based_on_fspeed",               true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "should_begin_sliding",              LVT_FUNCTION,  (size_t) "should_begin_sliding_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "should_get_stuck_in_ground",        LVT_FUNCTION,  (size_t) "should_get_stuck_in_ground_SPOOFED",            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "should_push_or_pull_door",          LVT_FUNCTION,  (size_t) "should_push_or_pull_door_SPOOFED",              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "should_start_or_continue_dialog",   LVT_FUNCTION,  (size_t) "should_start_or_continue_dialog_SPOOFED",       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "skipWarpInteractionsTimer",         LVT_U8,        offsetof(struct MarioState, skipWarpInteractionsTimer),   false, LOT_NONE,              1, sizeof(u8)                        },
+    { "slideVelX",                         LVT_F32,       offsetof(struct MarioState, slideVelX),                   false, LOT_NONE,              1, sizeof(f32)                       },
+    { "slideVelZ",                         LVT_F32,       offsetof(struct MarioState, slideVelZ),                   false, LOT_NONE,              1, sizeof(f32)                       },
+    { "slideYaw",                          LVT_S16,       offsetof(struct MarioState, slideYaw),                    false, LOT_NONE,              1, sizeof(s16)                       },
+    { "slide_bonk",                        LVT_FUNCTION,  (size_t) "slide_bonk",                                    true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "spawnInfo",                         LVT_COBJECT_P, offsetof(struct MarioState, spawnInfo),                   false, LOT_SPAWNINFO,         1, sizeof(struct SpawnInfo*)         },
+    { "specialTripleJump",                 LVT_U8,        offsetof(struct MarioState, specialTripleJump),           false, LOT_NONE,              1, sizeof(u8)                        },
+    { "splineKeyframe",                    LVT_COBJECT_P, offsetof(struct MarioState, splineKeyframe),              false, LOT_VEC4S,             1, sizeof(Vec4s*)                    },
+    { "splineKeyframeFraction",            LVT_F32,       offsetof(struct MarioState, splineKeyframeFraction),      false, LOT_NONE,              1, sizeof(f32)                       },
+    { "splineState",                       LVT_S32,       offsetof(struct MarioState, splineState),                 false, LOT_NONE,              1, sizeof(s32)                       },
+    { "spline_get_weights",                LVT_FUNCTION,  (size_t) "spline_get_weights",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "squishTimer",                       LVT_U8,        offsetof(struct MarioState, squishTimer),                 false, LOT_NONE,              1, sizeof(u8)                        },
+    { "stationary_ground_step",            LVT_FUNCTION,  (size_t) "stationary_ground_step",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "statusForCamera",                   LVT_COBJECT_P, offsetof(struct MarioState, statusForCamera),             true,  LOT_PLAYERCAMERASTATE, 1, sizeof(struct PlayerCameraState*) },
+    { "stomach_slide_action",              LVT_FUNCTION,  (size_t) "stomach_slide_action_SPOOFED",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "stop_and_set_height_to_floor",      LVT_FUNCTION,  (size_t) "stop_and_set_height_to_floor",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "stop_riding_and_holding",           LVT_FUNCTION,  (size_t) "mario_stop_riding_and_holding",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "stop_riding_object",                LVT_FUNCTION,  (size_t) "mario_stop_riding_object",                      true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "stopping_step",                     LVT_FUNCTION,  (size_t) "stopping_step",                                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "stuck_in_ground_handler",           LVT_FUNCTION,  (size_t) "stuck_in_ground_handler",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "take_damage_and_knock_back",        LVT_FUNCTION,  (size_t) "take_damage_and_knock_back_SPOOFED",            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "terrainSoundAddend",                LVT_U32,       offsetof(struct MarioState, terrainSoundAddend),          false, LOT_NONE,              1, sizeof(u32)                       },
+    { "throw_held_object",                 LVT_FUNCTION,  (size_t) "mario_throw_held_object",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "tilt_body_butt_slide",              LVT_FUNCTION,  (size_t) "tilt_body_butt_slide",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "tilt_body_ground_shell",            LVT_FUNCTION,  (size_t) "tilt_body_ground_shell",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "tilt_body_running",                 LVT_FUNCTION,  (size_t) "tilt_body_running",                             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "tilt_body_walking",                 LVT_FUNCTION,  (size_t) "tilt_body_walking",                             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "transition_submerged_to_walking",   LVT_FUNCTION,  (size_t) "transition_submerged_to_walking_SPOOFED",       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "twirlYaw",                          LVT_S16,       offsetof(struct MarioState, twirlYaw),                    false, LOT_NONE,              1, sizeof(s16)                       },
+    { "unkB0",                             LVT_S16,       offsetof(struct MarioState, unkB0),                       false, LOT_NONE,              1, sizeof(s16)                       },
+    { "unkC4",                             LVT_F32,       offsetof(struct MarioState, unkC4),                       false, LOT_NONE,              1, sizeof(f32)                       },
+    { "update_air_with_turn",              LVT_FUNCTION,  (size_t) "update_air_with_turn",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_air_without_turn",           LVT_FUNCTION,  (size_t) "update_air_without_turn",                       true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_character_anim_offset",      LVT_FUNCTION,  (size_t) "update_character_anim_offset",                  true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_decelerating_speed",         LVT_FUNCTION,  (size_t) "update_decelerating_speed_SPOOFED",             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_flying",                     LVT_FUNCTION,  (size_t) "update_flying",                                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_flying_pitch",               LVT_FUNCTION,  (size_t) "update_flying_pitch",                           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_flying_yaw",                 LVT_FUNCTION,  (size_t) "update_flying_yaw",                             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_hang_moving",                LVT_FUNCTION,  (size_t) "update_hang_moving",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_hang_stationary",            LVT_FUNCTION,  (size_t) "update_hang_stationary",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_lava_boost_or_twirling",     LVT_FUNCTION,  (size_t) "update_lava_boost_or_twirling",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_ledge_climb",                LVT_FUNCTION,  (size_t) "update_ledge_climb",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_ledge_climb_camera",         LVT_FUNCTION,  (size_t) "update_ledge_climb_camera",                     true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_moving_sand",                LVT_FUNCTION,  (size_t) "mario_update_moving_sand_SPOOFED",              true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_pos_for_anim",               LVT_FUNCTION,  (size_t) "update_mario_pos_for_anim",                     true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_punch_sequence",             LVT_FUNCTION,  (size_t) "mario_update_punch_sequence_SPOOFED",           true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_quicksand",                  LVT_FUNCTION,  (size_t) "mario_update_quicksand_SPOOFED",                true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_shell_speed",                LVT_FUNCTION,  (size_t) "update_shell_speed",                            true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_sliding",                    LVT_FUNCTION,  (size_t) "update_sliding_SPOOFED",                        true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_sliding_angle",              LVT_FUNCTION,  (size_t) "update_sliding_angle",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_sound_and_camera",           LVT_FUNCTION,  (size_t) "update_mario_sound_and_camera",                 true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_walking_speed",              LVT_FUNCTION,  (size_t) "update_walking_speed",                          true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_wall",                       LVT_FUNCTION,  (size_t) "mario_update_wall",                             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "update_windy_ground",               LVT_FUNCTION,  (size_t) "mario_update_windy_ground_SPOOFED",             true,  LOT_NONE,              1, sizeof(const char *)              },
+    { "usedObj",                           LVT_COBJECT_P, offsetof(struct MarioState, usedObj),                     false, LOT_OBJECT,            1, sizeof(struct Object*)            },
+    { "vel",                               LVT_COBJECT,   offsetof(struct MarioState, vel),                         true,  LOT_VEC3F,             1, sizeof(Vec3f)                     },
+    { "wall",                              LVT_COBJECT_P, offsetof(struct MarioState, wall),                        false, LOT_SURFACE,           1, sizeof(struct Surface*)           },
+    { "wallKickTimer",                     LVT_U8,        offsetof(struct MarioState, wallKickTimer),               false, LOT_NONE,              1, sizeof(u8)                        },
+    { "wallNormal",                        LVT_COBJECT,   offsetof(struct MarioState, wallNormal),                  true,  LOT_VEC3F,             1, sizeof(Vec3f)                     },
+    { "wasNetworkVisible",                 LVT_U8,        offsetof(struct MarioState, wasNetworkVisible),           false, LOT_NONE,              1, sizeof(u8)                        },
+    { "waterLevel",                        LVT_S16,       offsetof(struct MarioState, waterLevel),                  false, LOT_NONE,              1, sizeof(s16)                       },
 };
 
 #define LUA_MOD_FIELD_COUNT 17
@@ -1841,7 +1840,7 @@ static struct LuaObjectField sObjectFields[LUA_OBJECT_FIELD_COUNT] = {
 //  { "areaTimerRunOnceCallback)(void)",              LVT_???,                 offsetof(struct Object, areaTimerRunOnceCallback)(void)),            false, LOT_???,          1,                    sizeof(void (*)               }, <--- UNIMPLEMENTED
     { "areaTimerType",                                LVT_S32,                 offsetof(struct Object, areaTimerType),                              false, LOT_NONE,         1,                    sizeof(enum AreaTimerType)    },
     { "area_get_warp_node_from_params",               LVT_FUNCTION,            (size_t) "area_get_warp_node_from_params",                           true,  LOT_NONE,         1,                    sizeof(const char *)          },
-    { "attack_collided_from_other",                   LVT_FUNCTION,            (size_t) "obj_attack_collided_from_other_object",                    true,  LOT_NONE,         1,                    sizeof(const char *)          },
+    { "attack_collided_from_other",                   LVT_FUNCTION,            (size_t) "obj_attack_collided_from_other_object_SPOOFED",            true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "become_tangible",                              LVT_FUNCTION,            (size_t) "obj_become_tangible",                                      true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "behavior",                                     LVT_BEHAVIORSCRIPT_P,    offsetof(struct Object, behavior),                                   true,  LOT_POINTER,      1,                    sizeof(const BehaviorScript*) },
     { "bhvDelayTimer",                                LVT_S16,                 offsetof(struct Object, bhvDelayTimer),                              false, LOT_NONE,         1,                    sizeof(s16)                   },
@@ -1853,7 +1852,7 @@ static struct LuaObjectField sObjectFields[LUA_OBJECT_FIELD_COUNT] = {
     { "build_transform_relative_to_parent",           LVT_FUNCTION,            (size_t) "obj_build_transform_relative_to_parent",                   true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "build_vel_from_transform",                     LVT_FUNCTION,            (size_t) "obj_build_vel_from_transform",                             true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "check_hitbox_overlap",                         LVT_FUNCTION,            (size_t) "obj_check_hitbox_overlap",                                 true,  LOT_NONE,         1,                    sizeof(const char *)          },
-    { "check_if_collided_with",                       LVT_FUNCTION,            (size_t) "obj_check_if_collided_with_object",                        true,  LOT_NONE,         1,                    sizeof(const char *)          },
+    { "check_if_collided_with",                       LVT_FUNCTION,            (size_t) "obj_check_if_collided_with_object_SPOOFED",                true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "check_overlap_with_hitbox_params",             LVT_FUNCTION,            (size_t) "obj_check_overlap_with_hitbox_params",                     true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "collidedObjInteractTypes",                     LVT_U32,                 offsetof(struct Object, collidedObjInteractTypes),                   false, LOT_NONE,         1,                    sizeof(u32)                   },
     { "collidedObjs",                                 LVT_COBJECT_P,           offsetof(struct Object, collidedObjs),                               false, LOT_OBJECT,       4,                    sizeof(struct Object*)        },
@@ -1877,7 +1876,7 @@ static struct LuaObjectField sObjectFields[LUA_OBJECT_FIELD_COUNT] = {
     { "dist_betweens",                                LVT_FUNCTION,            (size_t) "dist_between_objects",                                     true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "execute_mario_action",                         LVT_FUNCTION,            (size_t) "execute_mario_action",                                     true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "find_mario_anim_flags_and_translation",        LVT_FUNCTION,            (size_t) "find_mario_anim_flags_and_translation",                    true,  LOT_NONE,         1,                    sizeof(const char *)          },
-    { "flicker_and_disappear",                        LVT_FUNCTION,            (size_t) "obj_flicker_and_disappear",                                true,  LOT_NONE,         1,                    sizeof(const char *)          },
+    { "flicker_and_disappear",                        LVT_FUNCTION,            (size_t) "obj_flicker_and_disappear_SPOOFED",                        true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "get_collided",                                 LVT_FUNCTION,            (size_t) "obj_get_collided_object",                                  true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "get_door_save_file_flag",                      LVT_FUNCTION,            (size_t) "get_door_save_file_flag",                                  true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "get_field_f32",                                LVT_FUNCTION,            (size_t) "obj_get_field_f32",                                        true,  LOT_NONE,         1,                    sizeof(const char *)          },
@@ -1895,9 +1894,9 @@ static struct LuaObjectField sObjectFields[LUA_OBJECT_FIELD_COUNT] = {
     { "get_next_with_same_behavior_id_and_field_s32", LVT_FUNCTION,            (size_t) "obj_get_next_with_same_behavior_id_and_field_s32",         true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "get_surface_from_index",                       LVT_FUNCTION,            (size_t) "obj_get_surface_from_index",                               true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "globalPlayerIndex",                            LVT_U8,                  offsetof(struct Object, globalPlayerIndex),                          false, LOT_NONE,         1,                    sizeof(u8)                    },
-    { "has_behavior",                                 LVT_FUNCTION,            (size_t) "obj_has_behavior",                                         true,  LOT_NONE,         1,                    sizeof(const char *)          },
-    { "has_behavior_id",                              LVT_FUNCTION,            (size_t) "obj_has_behavior_id",                                      true,  LOT_NONE,         1,                    sizeof(const char *)          },
-    { "has_model_extended",                           LVT_FUNCTION,            (size_t) "obj_has_model_extended",                                   true,  LOT_NONE,         1,                    sizeof(const char *)          },
+    { "has_behavior",                                 LVT_FUNCTION,            (size_t) "obj_has_behavior_SPOOFED",                                 true,  LOT_NONE,         1,                    sizeof(const char *)          },
+    { "has_behavior_id",                              LVT_FUNCTION,            (size_t) "obj_has_behavior_id_SPOOFED",                              true,  LOT_NONE,         1,                    sizeof(const char *)          },
+    { "has_model_extended",                           LVT_FUNCTION,            (size_t) "obj_has_model_extended_SPOOFED",                           true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "header",                                       LVT_COBJECT,             offsetof(struct Object, header),                                     true,  LOT_OBJECTNODE,   1,                    sizeof(struct ObjectNode)     },
     { "heldByPlayerIndex",                            LVT_U32,                 offsetof(struct Object, heldByPlayerIndex),                          false, LOT_NONE,         1,                    sizeof(u32)                   },
     { "hitboxDownOffset",                             LVT_F32,                 offsetof(struct Object, hitboxDownOffset),                           false, LOT_NONE,         1,                    sizeof(f32)                   },
@@ -1915,10 +1914,10 @@ static struct LuaObjectField sObjectFields[LUA_OBJECT_FIELD_COUNT] = {
     { "is_coin",                                      LVT_FUNCTION,            (size_t) "obj_is_coin",                                              true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "is_exclamation_box",                           LVT_FUNCTION,            (size_t) "obj_is_exclamation_box",                                   true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "is_grabbable",                                 LVT_FUNCTION,            (size_t) "obj_is_grabbable",                                         true,  LOT_NONE,         1,                    sizeof(const char *)          },
-    { "is_hidden",                                    LVT_FUNCTION,            (size_t) "obj_is_hidden",                                            true,  LOT_NONE,         1,                    sizeof(const char *)          },
+    { "is_hidden",                                    LVT_FUNCTION,            (size_t) "obj_is_hidden_SPOOFED",                                    true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "is_mushroom_1up",                              LVT_FUNCTION,            (size_t) "obj_is_mushroom_1up",                                      true,  LOT_NONE,         1,                    sizeof(const char *)          },
-    { "is_nearest_player_to",                         LVT_FUNCTION,            (size_t) "is_nearest_player_to_object",                              true,  LOT_NONE,         1,                    sizeof(const char *)          },
-    { "is_point_close_to",                            LVT_FUNCTION,            (size_t) "is_point_close_to_object",                                 true,  LOT_NONE,         1,                    sizeof(const char *)          },
+    { "is_nearest_player_to",                         LVT_FUNCTION,            (size_t) "is_nearest_player_to_object_SPOOFED",                      true,  LOT_NONE,         1,                    sizeof(const char *)          },
+    { "is_point_close_to",                            LVT_FUNCTION,            (size_t) "is_point_close_to_object_SPOOFED",                         true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "is_secret",                                    LVT_FUNCTION,            (size_t) "obj_is_secret",                                            true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "is_valid_for_interaction",                     LVT_FUNCTION,            (size_t) "obj_is_valid_for_interaction",                             true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "lateral_dist_betweens",                        LVT_FUNCTION,            (size_t) "lateral_dist_between_objects",                             true,  LOT_NONE,         1,                    sizeof(const char *)          },
@@ -2676,7 +2675,7 @@ static struct LuaObjectField sObjectFields[LUA_OBJECT_FIELD_COUNT] = {
 //  { "respawnInfo",                                  LVT_???,                 offsetof(struct Object, respawnInfo),                                false, LOT_???,          1,                    sizeof(void*)                 }, <--- UNIMPLEMENTED
     { "respawnInfoType",                              LVT_S16,                 offsetof(struct Object, respawnInfoType),                            true,  LOT_NONE,         1,                    sizeof(s16)                   },
     { "return_and_displace_home",                     LVT_FUNCTION,            (size_t) "obj_return_and_displace_home",                             true,  LOT_NONE,         1,                    sizeof(const char *)          },
-    { "return_home_if_safe",                          LVT_FUNCTION,            (size_t) "obj_return_home_if_safe",                                  true,  LOT_NONE,         1,                    sizeof(const char *)          },
+    { "return_home_if_safe",                          LVT_FUNCTION,            (size_t) "obj_return_home_if_safe_SPOOFED",                          true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "rotate_towards_point",                         LVT_FUNCTION,            (size_t) "obj_rotate_towards_point",                                 true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "scale",                                        LVT_FUNCTION,            (size_t) "obj_scale",                                                true,  LOT_NONE,         1,                    sizeof(const char *)          },
     { "scale_random",                                 LVT_FUNCTION,            (size_t) "obj_scale_random",                                         true,  LOT_NONE,         1,                    sizeof(const char *)          },
@@ -2956,29 +2955,29 @@ static struct LuaObjectField sStaticObjectCollisionFields[LUA_STATIC_OBJECT_COLL
 
 #define LUA_SURFACE_FIELD_COUNT 23
 static struct LuaObjectField sSurfaceFields[LUA_SURFACE_FIELD_COUNT] = {
-    { "calc_new_obj_vel_and_pos_y",            LVT_FUNCTION,  (size_t) "calc_new_obj_vel_and_pos_y",            true,  LOT_NONE,   1, sizeof(const char *)   },
-    { "calc_new_obj_vel_and_pos_y_underwater", LVT_FUNCTION,  (size_t) "calc_new_obj_vel_and_pos_y_underwater", true,  LOT_NONE,   1, sizeof(const char *)   },
-    { "closest_point_to_triangle",             LVT_FUNCTION,  (size_t) "closest_point_to_triangle",             true,  LOT_NONE,   1, sizeof(const char *)   },
-    { "flags",                                 LVT_S8,        offsetof(struct Surface, flags),                  false, LOT_NONE,   1, sizeof(s8)             },
-    { "force",                                 LVT_S16,       offsetof(struct Surface, force),                  false, LOT_NONE,   1, sizeof(s16)            },
-    { "is_not_hard",                           LVT_FUNCTION,  (size_t) "surface_is_not_hard",                   true,  LOT_NONE,   1, sizeof(const char *)   },
-    { "is_painting_warp",                      LVT_FUNCTION,  (size_t) "surface_is_painting_warp",              true,  LOT_NONE,   1, sizeof(const char *)   },
-    { "is_quicksand",                          LVT_FUNCTION,  (size_t) "surface_is_quicksand",                  true,  LOT_NONE,   1, sizeof(const char *)   },
-    { "lowerY",                                LVT_S16,       offsetof(struct Surface, lowerY),                 false, LOT_NONE,   1, sizeof(s16)            },
-    { "modifiedTimestamp",                     LVT_U32,       offsetof(struct Surface, modifiedTimestamp),      false, LOT_NONE,   1, sizeof(u32)            },
-    { "normal",                                LVT_COBJECT,   offsetof(struct Surface, normal),                 true,  LOT_VEC3F,  1, sizeof(Vec3f)          },
-    { "object",                                LVT_COBJECT_P, offsetof(struct Surface, object),                 false, LOT_OBJECT, 1, sizeof(struct Object*) },
-    { "originOffset",                          LVT_F32,       offsetof(struct Surface, originOffset),           false, LOT_NONE,   1, sizeof(f32)            },
-    { "prevVertex1",                           LVT_COBJECT,   offsetof(struct Surface, prevVertex1),            true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
-    { "prevVertex2",                           LVT_COBJECT,   offsetof(struct Surface, prevVertex2),            true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
-    { "prevVertex3",                           LVT_COBJECT,   offsetof(struct Surface, prevVertex3),            true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
-    { "room",                                  LVT_S8,        offsetof(struct Surface, room),                   false, LOT_NONE,   1, sizeof(s8)             },
-    { "turn_obj_away_from_steep_floor",        LVT_FUNCTION,  (size_t) "turn_obj_away_from_steep_floor",        true,  LOT_NONE,   1, sizeof(const char *)   },
-    { "type",                                  LVT_S16,       offsetof(struct Surface, type),                   false, LOT_NONE,   1, sizeof(s16)            },
-    { "upperY",                                LVT_S16,       offsetof(struct Surface, upperY),                 false, LOT_NONE,   1, sizeof(s16)            },
-    { "vertex1",                               LVT_COBJECT,   offsetof(struct Surface, vertex1),                true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
-    { "vertex2",                               LVT_COBJECT,   offsetof(struct Surface, vertex2),                true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
-    { "vertex3",                               LVT_COBJECT,   offsetof(struct Surface, vertex3),                true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
+    { "calc_new_obj_vel_and_pos_y",            LVT_FUNCTION,  (size_t) "calc_new_obj_vel_and_pos_y",             true,  LOT_NONE,   1, sizeof(const char *)   },
+    { "calc_new_obj_vel_and_pos_y_underwater", LVT_FUNCTION,  (size_t) "calc_new_obj_vel_and_pos_y_underwater",  true,  LOT_NONE,   1, sizeof(const char *)   },
+    { "closest_point_to_triangle",             LVT_FUNCTION,  (size_t) "closest_point_to_triangle",              true,  LOT_NONE,   1, sizeof(const char *)   },
+    { "flags",                                 LVT_S8,        offsetof(struct Surface, flags),                   false, LOT_NONE,   1, sizeof(s8)             },
+    { "force",                                 LVT_S16,       offsetof(struct Surface, force),                   false, LOT_NONE,   1, sizeof(s16)            },
+    { "is_not_hard",                           LVT_FUNCTION,  (size_t) "surface_is_not_hard",                    true,  LOT_NONE,   1, sizeof(const char *)   },
+    { "is_painting_warp",                      LVT_FUNCTION,  (size_t) "surface_is_painting_warp",               true,  LOT_NONE,   1, sizeof(const char *)   },
+    { "is_quicksand",                          LVT_FUNCTION,  (size_t) "surface_is_quicksand",                   true,  LOT_NONE,   1, sizeof(const char *)   },
+    { "lowerY",                                LVT_S16,       offsetof(struct Surface, lowerY),                  false, LOT_NONE,   1, sizeof(s16)            },
+    { "modifiedTimestamp",                     LVT_U32,       offsetof(struct Surface, modifiedTimestamp),       false, LOT_NONE,   1, sizeof(u32)            },
+    { "normal",                                LVT_COBJECT,   offsetof(struct Surface, normal),                  true,  LOT_VEC3F,  1, sizeof(Vec3f)          },
+    { "object",                                LVT_COBJECT_P, offsetof(struct Surface, object),                  false, LOT_OBJECT, 1, sizeof(struct Object*) },
+    { "originOffset",                          LVT_F32,       offsetof(struct Surface, originOffset),            false, LOT_NONE,   1, sizeof(f32)            },
+    { "prevVertex1",                           LVT_COBJECT,   offsetof(struct Surface, prevVertex1),             true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
+    { "prevVertex2",                           LVT_COBJECT,   offsetof(struct Surface, prevVertex2),             true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
+    { "prevVertex3",                           LVT_COBJECT,   offsetof(struct Surface, prevVertex3),             true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
+    { "room",                                  LVT_S8,        offsetof(struct Surface, room),                    false, LOT_NONE,   1, sizeof(s8)             },
+    { "turn_obj_away_from_steep_floor",        LVT_FUNCTION,  (size_t) "turn_obj_away_from_steep_floor_SPOOFED", true,  LOT_NONE,   1, sizeof(const char *)   },
+    { "type",                                  LVT_S16,       offsetof(struct Surface, type),                    false, LOT_NONE,   1, sizeof(s16)            },
+    { "upperY",                                LVT_S16,       offsetof(struct Surface, upperY),                  false, LOT_NONE,   1, sizeof(s16)            },
+    { "vertex1",                               LVT_COBJECT,   offsetof(struct Surface, vertex1),                 true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
+    { "vertex2",                               LVT_COBJECT,   offsetof(struct Surface, vertex2),                 true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
+    { "vertex3",                               LVT_COBJECT,   offsetof(struct Surface, vertex3),                 true,  LOT_VEC3S,  1, sizeof(Vec3s)          },
 };
 
 #define LUA_TEXTURE_INFO_FIELD_COUNT 6