thirdpartymirrors/sm64coopdx
1
0
Fork 0
mirror of https://github.com/coop-deluxe/sm64coopdx.git synced 2026-04-21 17:41:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Create spoof implementation

Browse source
This commit is contained in:
Sunketchupm 2026-01-29 13:40:10 -05:00
parent e693215054
commit cd9f83dd75
6 changed files with 728 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
autogen/common.py
View file

@ -53,6 +53,10 @@ exclude_structs = [
override_types = { "Gfx", "Vtx" }
spoof_functions = [
"interact_*"
]
def extract_integer_datatype(c_type):
c_type = c_type.strip().lower()
c_type = re.sub(r'\*|\[.*?\]', '', c_type)

36
autogen/convert_functions.py
View file

@ -842,7 +842,7 @@ def build_param_after(param, i):
else:
return ''
def build_return_value(id, rtype):
def build_return_value(id, rtype, spoof_ret_as_bool):
rtype = alter_type(rtype)
lot = translate_type_to_lot(rtype)
@ -866,10 +866,13 @@ def build_return_value(id, rtype):
return ' smlua_push_pointer(L, %s, (void*)%s, NULL);\n' % (lvt, id)
elif '???' not in lot and lot != 'LOT_NONE':
return ' smlua_push_object(L, %s, %s, NULL);\n' % (lot, id)
if spoof_ret_as_bool:
lfunc = 'lua_pushboolean'
return ' %s(L, %s);\n' % (lfunc, id)
def build_call(function):
def build_call(function, spoof_ret_as_bool):
ftype = alter_type(function['type'])
fid = function['identifier']
@ -885,7 +888,7 @@ def build_call(function):
if ftype in VECP_TYPES:
return ' %s;\n' % ccall
return build_return_value(ccall, ftype)
return build_return_value(ccall, ftype, spoof_ret_as_bool)
def split_function_parameters_and_returns(function):
fparams = []
@ -901,9 +904,12 @@ def split_function_parameters_and_returns(function):
fparams.append(param)
return fparams, freturns
def build_function(function, do_extern):
def build_function(function, do_extern, spoof_ret_as_bool):
s = ''
fid = function['identifier']
spoof_text = ""
if spoof_ret_as_bool:
spoof_text = "_SPOOFED"
if fid in override_function_version_excludes:
s += '#ifndef ' + override_function_version_excludes[fid] + '\n'
@ -911,9 +917,9 @@ def build_function(function, do_extern):
fparams, freturns = split_function_parameters_and_returns(function)
if len(function['params']) <= 0:
s += 'int smlua_func_%s(UNUSED lua_State* L) {\n' % function['identifier']
s += 'int smlua_func_%s%s(UNUSED lua_State* L) {\n' % (function['identifier'], spoof_text)
else:
s += 'int smlua_func_%s(lua_State* L) {\n' % function['identifier']
s += 'int smlua_func_%s%s(lua_State* L) {\n' % (function['identifier'], spoof_text)
# make sure the bhv functions have a current object
fname = function['filename']
@ -976,7 +982,7 @@ def build_function(function, do_extern):
# special case for interaction functions to call the hooks associated with interactions
s += " lua_pushinteger(L, process_interaction(m, " + fid.upper() + ", o, " + fid + "));\n"
else:
call_str = build_call(function)
call_str = build_call(function, spoof_ret_as_bool)
push_value = "lua_push" in call_str
s += call_str
@ -998,7 +1004,7 @@ def build_function(function, do_extern):
for param in freturns:
pid = param['identifier']
ptype = alter_type(param['rtype'])
s += build_return_value(pid, ptype)
s += build_return_value(pid, ptype, False)
s += '\n'
num_returns = max(1, push_value + len(freturns))
@ -1028,11 +1034,16 @@ def build_functions(processed_files):
for function in processed_file['functions']:
function['filename'] = processed_file['filename']
s += build_function(function, processed_file['extern'])
s += build_function(function, processed_file['extern'], False)
for func in spoof_functions:
if re.match(func, function["identifier"]):
s += build_function(function, processed_file['extern'], True)
return s
def build_bind(function):
def build_bind(function, spoof_bind):
fid = function['identifier']
if spoof_bind:
fid = fid + "_SPOOFED"
s = 'smlua_bind_function(L, "%s", smlua_func_%s);' % (fid, fid)
if function['implemented']:
s = ' ' + s
@ -1051,7 +1062,10 @@ def build_binds(processed_files):
s += "\n // " + processed_file['filename'] + "\n"
for function in processed_file['functions']:
s += build_bind(function)
s += build_bind(function, False)
for func in spoof_functions:
if re.match(func, function["identifier"]):
s += build_bind(function, True)
return s
def build_includes():

10
autogen/convert_structs.py
View file

@ -613,6 +613,11 @@ def build_struct(struct):
field_table.append(row)
for name, real_name, _ in extracted_functions_info(sid, extracted_functions):
for func in spoof_functions:
if re.match(func, real_name):
real_name = real_name + "_SPOOFED"
break
row = [
' { ',
'"%s", ' % name,
@ -876,9 +881,12 @@ def get_function_signature(function):
sig = 'fun('
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:
if re.match(func, function_name):
function_return = "boolean"
if function_return:
sig += ': %s' % (function_return)
function_name = line.replace('(', ' ').split()[1]
function_signatures[function_name] = sig
function_params.clear()
function_return = None

60
autogen/lua_definitions/structs.lua
View file

@ -1190,36 +1190,36 @@
--- @field public get_character_anim fun(m: MarioState, characterAnim: CharacterAnimID): integer Gets the animation ID to use for a specific character and animation combination. The ID is based on `characterAnim` and the character currently controlled by Mario (`m`). Useful for determining which animation to play for actions like walking, jumping, or idle states
--- @field public update_character_anim_offset fun(m: MarioState) Updates Mario's current animation offset. This adjusts Mario's position based on the calculated offset to ensure animations appear smooth and natural. Useful for keeping Mario's animations visually aligned, particularly when transitioning between animations
--- @field public first_person_check_cancels fun(m: MarioState): boolean Checks common cancels for first person
--- @field public interact_coin fun(m: MarioState, interactType: integer, o: Object): integer Handles Mario's interaction with coins. Collecting a coin increases Mario's coin count and heals him slightly. Useful for score, and coin management
--- @field public interact_water_ring fun(m: MarioState, interactType: integer, o: Object): integer Handles interactions with water rings that heal Mario. Passing through water rings increases his health counter. Useful for underwater stages
--- @field public interact_star_or_key fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with Stars or Keys. If Mario collects a star or key, it triggers a specific star grab cutscene and progression is updated. Also handles no-exit variants (like the wing cap stage star). Useful for the main progression system of collecting Stars and unlocking new areas
--- @field public interact_bbh_entrance fun(m: MarioState, interactType: integer, o: Object): integer Handles Mario's interaction with the Boo's Big Haunt (BBH) entrance object. When Mario tries to enter the BBH area, this function determines the resulting action (e.g., a jump or spin entrance)
--- @field public interact_warp fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with warps, including warp pipes and hole warps. If Mario steps onto a warp, he either transitions into another area or level. Useful for connecting different parts of the game world and controlling transitions between levels as well as custom warp areas
--- @field public interact_warp_door fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with warp doors that lead to other areas or require keys. If Mario can open the door (has enough stars or a key), he proceeds. Otherwise, it may show a dialog. Useful for restricting access to certain areas based on progression
--- @field public interact_door fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction when Mario touches a door. If Mario meets the star requirement or has the key, he can unlock/open the door. Otherwise, it may display dialog indicating the requirement. Useful for controlling access to locked areas and providing progression gating in the game
--- @field public interact_cannon_base fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction when Mario touches a cannon base. If the cannon is ready, Mario enters the cannon, triggering a special action and camera behavior. Useful for transitioning to cannon-aiming mode and enabling cannon travel within levels
--- @field public interact_player fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with another player (in multiplayer scenarios). Checks if Mario and another player collide and resolves any special behavior like bouncing on top. Useful for multiplayer interactions, such as PvP or cooperative gameplay mechanics
--- @field public interact_igloo_barrier fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with the igloo barrier found in Snowman's Land. If Mario runs into the barrier, this function pushes him away and prevents passage without the vanish cap. Useful for enforcing require-caps to access certain areas
--- @field public interact_tornado fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with tornados. If Mario touches a tornado, he enters a spinning twirl action, losing control temporarily. Useful for desert levels or areas where environmental hazards lift Mario into the air
--- @field public interact_whirlpool fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with whirlpools. If Mario gets caught in a whirlpool, he's pulled toward it, resulting in a unique "caught" action. Useful for hazards that trap Mario like whirlpools
--- @field public interact_strong_wind fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with strong wind gusts. These gusts push Mario back, often knocking him off platforms or sending him flying backwards. Useful for environmental wind hazards
--- @field public interact_flame fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with flame objects. If Mario touches a flame and is not invulnerable or protected by certain caps, he takes damage and may be set on fire, causing a burning jump. Useful for simulating fire damage and hazards in levels
--- @field public interact_snufit_bullet fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with Snufit bullets (projectiles fired by certain enemies). If Mario is not protected, he takes damage. Otherwise, the bullet can be destroyed
--- @field public interact_clam_or_bubba fun(m: MarioState, interactType: integer, o: Object): integer Handles interactions with objects like Clams or Bubbas, which can damage Mario or, in Bubba's case, eat Mario. If Bubba eats Mario, it triggers a unique "caught" action. Otherwise, it deals damage and knockback if hit by a Clam
--- @field public interact_bully fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with Bully enemies. Determines if Mario attacks the Bully or gets knocked back. Updates Mario's velocity and state accordingly, and can defeat the Bully if attacked successfully. Useful for enemy encounters that involve pushing and shoving mechanics rather than just stomping like the bullies
--- @field public interact_shock fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with shocking objects. If Mario touches an electrified enemy or hazard, he takes damage and may be stunned or shocked. Useful for electric-themed enemies and obstacles
--- @field public interact_mr_blizzard fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with Mr. Blizzard (the snowman enemy) or similar objects. If Mario is attacked or collides with Mr. Blizzard, it applies damage and knockback if not protected or attacking
--- @field public interact_hit_from_below fun(m: MarioState, interactType: integer, o: Object): integer Handles interactions where Mario hits an object from below (e.g., hitting a block from underneath). Determines if Mario damages/destroys the object, or if it damages Mario. Useful for handling upward attacks, hitting coin blocks, or interacting with certain NPCs from below
--- @field public interact_bounce_top fun(m: MarioState, interactType: integer, o: Object): integer Handles interactions where Mario bounces off the top of an object (e.g., Goombas, Koopas). Checks if Mario attacks the object from above and applies the appropriate knockback, sound effects, and object state changes. Useful for enemy defeat mechanics and platform bouncing
--- @field public interact_spiny_walking fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with Spiny-walking enemies. If Mario attacks it (e.g., by punching), the enemy is hurt. If he fails to attack properly (say bouncing on top), Mario takes damage and knockback. Useful for enemies that cannot be stomped from above and require direct attacks
--- @field public interact_damage fun(m: MarioState, interactType: integer, o: Object): integer Handles damaging interactions from various objects (e.g., enemies, hazards). If Mario takes damage, it applies knockback and reduces health. Useful for enemy attacks, environmental hazards, and managing damage related behaviors
--- @field public interact_breakable fun(m: MarioState, interactType: integer, o: Object): integer Handles interactions with breakable objects (e.g., breakable boxes or bob-ombs). If Mario hits the object with a valid attack (like a punch or kick), the object is destroyed or changes state. Useful for managing collectible items hidden in breakable objects and level progression through destructible blocks or walls
--- @field public interact_koopa_shell fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction when Mario touches a Koopa Shell. If conditions are met, Mario can hop onto the shell and start riding it, changing his movement mechanics. Useful for implementing Koopa Shell behavior
--- @field public interact_pole fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with poles (e.g., climbing poles). If Mario runs into a vertical pole, he can grab it and start climbing. Useful for platforming mechanics
--- @field public interact_hoot fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with Hoot, the owl. If Mario can grab onto Hoot, this sets Mario onto a riding action, allowing him to fly around the level. Useful for special traversal mechanics and shortcuts within a course
--- @field public interact_cap fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction when Mario picks up a cap object. This includes normal caps, wing caps, vanish caps, and metal caps. Updates Mario's state (e.g., cap timers, sound effects) and may initiate putting on the cap animation. Useful for managing cap statuses
--- @field public interact_grabbable fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with grabbable objects (e.g., crates, small enemies, or Bowser). Checks if Mario can pick up the object and initiates the grab action if possible. Useful for course mechanics, throwing items, and Bowser
--- @field public interact_text fun(m: MarioState, interactType: integer, o: Object): integer Handles interaction with signs, NPCs, and other text-bearing objects. If Mario presses the interact button facing them, he enters a dialog reading state. Useful for managing hints, story elements, or gameplay instructions through in-game dialogue
--- @field public interact_coin fun(m: MarioState, interactType: integer, o: Object): boolean Handles Mario's interaction with coins. Collecting a coin increases Mario's coin count and heals him slightly. Useful for score, and coin management
--- @field public interact_water_ring fun(m: MarioState, interactType: integer, o: Object): boolean Handles interactions with water rings that heal Mario. Passing through water rings increases his health counter. Useful for underwater stages
--- @field public interact_star_or_key fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with Stars or Keys. If Mario collects a star or key, it triggers a specific star grab cutscene and progression is updated. Also handles no-exit variants (like the wing cap stage star). Useful for the main progression system of collecting Stars and unlocking new areas
--- @field public interact_bbh_entrance fun(m: MarioState, interactType: integer, o: Object): boolean Handles Mario's interaction with the Boo's Big Haunt (BBH) entrance object. When Mario tries to enter the BBH area, this function determines the resulting action (e.g., a jump or spin entrance)
--- @field public interact_warp fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with warps, including warp pipes and hole warps. If Mario steps onto a warp, he either transitions into another area or level. Useful for connecting different parts of the game world and controlling transitions between levels as well as custom warp areas
--- @field public interact_warp_door fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with warp doors that lead to other areas or require keys. If Mario can open the door (has enough stars or a key), he proceeds. Otherwise, it may show a dialog. Useful for restricting access to certain areas based on progression
--- @field public interact_door fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction when Mario touches a door. If Mario meets the star requirement or has the key, he can unlock/open the door. Otherwise, it may display dialog indicating the requirement. Useful for controlling access to locked areas and providing progression gating in the game
--- @field public interact_cannon_base fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction when Mario touches a cannon base. If the cannon is ready, Mario enters the cannon, triggering a special action and camera behavior. Useful for transitioning to cannon-aiming mode and enabling cannon travel within levels
--- @field public interact_player fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with another player (in multiplayer scenarios). Checks if Mario and another player collide and resolves any special behavior like bouncing on top. Useful for multiplayer interactions, such as PvP or cooperative gameplay mechanics
--- @field public interact_igloo_barrier fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with the igloo barrier found in Snowman's Land. If Mario runs into the barrier, this function pushes him away and prevents passage without the vanish cap. Useful for enforcing require-caps to access certain areas
--- @field public interact_tornado fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with tornados. If Mario touches a tornado, he enters a spinning twirl action, losing control temporarily. Useful for desert levels or areas where environmental hazards lift Mario into the air
--- @field public interact_whirlpool fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with whirlpools. If Mario gets caught in a whirlpool, he's pulled toward it, resulting in a unique "caught" action. Useful for hazards that trap Mario like whirlpools
--- @field public interact_strong_wind fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with strong wind gusts. These gusts push Mario back, often knocking him off platforms or sending him flying backwards. Useful for environmental wind hazards
--- @field public interact_flame fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with flame objects. If Mario touches a flame and is not invulnerable or protected by certain caps, he takes damage and may be set on fire, causing a burning jump. Useful for simulating fire damage and hazards in levels
--- @field public interact_snufit_bullet fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with Snufit bullets (projectiles fired by certain enemies). If Mario is not protected, he takes damage. Otherwise, the bullet can be destroyed
--- @field public interact_clam_or_bubba fun(m: MarioState, interactType: integer, o: Object): boolean Handles interactions with objects like Clams or Bubbas, which can damage Mario or, in Bubba's case, eat Mario. If Bubba eats Mario, it triggers a unique "caught" action. Otherwise, it deals damage and knockback if hit by a Clam
--- @field public interact_bully fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with Bully enemies. Determines if Mario attacks the Bully or gets knocked back. Updates Mario's velocity and state accordingly, and can defeat the Bully if attacked successfully. Useful for enemy encounters that involve pushing and shoving mechanics rather than just stomping like the bullies
--- @field public interact_shock fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with shocking objects. If Mario touches an electrified enemy or hazard, he takes damage and may be stunned or shocked. Useful for electric-themed enemies and obstacles
--- @field public interact_mr_blizzard fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with Mr. Blizzard (the snowman enemy) or similar objects. If Mario is attacked or collides with Mr. Blizzard, it applies damage and knockback if not protected or attacking
--- @field public interact_hit_from_below fun(m: MarioState, interactType: integer, o: Object): boolean Handles interactions where Mario hits an object from below (e.g., hitting a block from underneath). Determines if Mario damages/destroys the object, or if it damages Mario. Useful for handling upward attacks, hitting coin blocks, or interacting with certain NPCs from below
--- @field public interact_bounce_top fun(m: MarioState, interactType: integer, o: Object): boolean Handles interactions where Mario bounces off the top of an object (e.g., Goombas, Koopas). Checks if Mario attacks the object from above and applies the appropriate knockback, sound effects, and object state changes. Useful for enemy defeat mechanics and platform bouncing
--- @field public interact_spiny_walking fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with Spiny-walking enemies. If Mario attacks it (e.g., by punching), the enemy is hurt. If he fails to attack properly (say bouncing on top), Mario takes damage and knockback. Useful for enemies that cannot be stomped from above and require direct attacks
--- @field public interact_damage fun(m: MarioState, interactType: integer, o: Object): boolean Handles damaging interactions from various objects (e.g., enemies, hazards). If Mario takes damage, it applies knockback and reduces health. Useful for enemy attacks, environmental hazards, and managing damage related behaviors
--- @field public interact_breakable fun(m: MarioState, interactType: integer, o: Object): boolean Handles interactions with breakable objects (e.g., breakable boxes or bob-ombs). If Mario hits the object with a valid attack (like a punch or kick), the object is destroyed or changes state. Useful for managing collectible items hidden in breakable objects and level progression through destructible blocks or walls
--- @field public interact_koopa_shell fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction when Mario touches a Koopa Shell. If conditions are met, Mario can hop onto the shell and start riding it, changing his movement mechanics. Useful for implementing Koopa Shell behavior
--- @field public interact_pole fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with poles (e.g., climbing poles). If Mario runs into a vertical pole, he can grab it and start climbing. Useful for platforming mechanics
--- @field public interact_hoot fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with Hoot, the owl. If Mario can grab onto Hoot, this sets Mario onto a riding action, allowing him to fly around the level. Useful for special traversal mechanics and shortcuts within a course
--- @field public interact_cap fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction when Mario picks up a cap object. This includes normal caps, wing caps, vanish caps, and metal caps. Updates Mario's state (e.g., cap timers, sound effects) and may initiate putting on the cap animation. Useful for managing cap statuses
--- @field public interact_grabbable fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with grabbable objects (e.g., crates, small enemies, or Bowser). Checks if Mario can pick up the object and initiates the grab action if possible. Useful for course mechanics, throwing items, and Bowser
--- @field public interact_text fun(m: MarioState, interactType: integer, o: Object): boolean Handles interaction with signs, NPCs, and other text-bearing objects. If Mario presses the interact button facing them, he enters a dialog reading state. Useful for managing hints, story elements, or gameplay instructions through in-game dialogue
--- @field public obj_angle_to_object fun(m: MarioState, o: Object): integer Calculates the angle between Mario and a specified object. Used for determining Mario's orientation relative to the object. Useful for deciding directions between Mario and NPCs
--- @field public stop_riding_object fun(m: MarioState) Stops Mario from riding any currently ridden object (e.g., a Koopa shell or Hoot), updating the object's interaction status and Mario's state. Useful for cleanly dismounting ridden objects
--- @field public grab_used_object fun(m: MarioState) Grabs the object currently referenced by Mario's `usedObj` if it's not already being held. Changes the object's state to indicate it is now held by Mario. Useful for handling the moment Mario successfully picks up an object

60
src/pc/lua/smlua_cobject_autogen.c
View file

@ -1520,36 +1520,36 @@ static struct LuaObjectField sMarioStateFields[LUA_MARIO_STATE_FIELD_COUNT] = {
{ "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", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_bounce_top", LVT_FUNCTION, (size_t) "interact_bounce_top", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_breakable", LVT_FUNCTION, (size_t) "interact_breakable", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_bully", LVT_FUNCTION, (size_t) "interact_bully", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_cannon_base", LVT_FUNCTION, (size_t) "interact_cannon_base", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_cap", LVT_FUNCTION, (size_t) "interact_cap", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_clam_or_bubba", LVT_FUNCTION, (size_t) "interact_clam_or_bubba", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_coin", LVT_FUNCTION, (size_t) "interact_coin", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_damage", LVT_FUNCTION, (size_t) "interact_damage", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_door", LVT_FUNCTION, (size_t) "interact_door", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_flame", LVT_FUNCTION, (size_t) "interact_flame", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_grabbable", LVT_FUNCTION, (size_t) "interact_grabbable", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_hit_from_below", LVT_FUNCTION, (size_t) "interact_hit_from_below", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_hoot", LVT_FUNCTION, (size_t) "interact_hoot", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_igloo_barrier", LVT_FUNCTION, (size_t) "interact_igloo_barrier", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_koopa_shell", LVT_FUNCTION, (size_t) "interact_koopa_shell", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_mr_blizzard", LVT_FUNCTION, (size_t) "interact_mr_blizzard", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_player", LVT_FUNCTION, (size_t) "interact_player", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_pole", LVT_FUNCTION, (size_t) "interact_pole", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_shock", LVT_FUNCTION, (size_t) "interact_shock", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_snufit_bullet", LVT_FUNCTION, (size_t) "interact_snufit_bullet", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_spiny_walking", LVT_FUNCTION, (size_t) "interact_spiny_walking", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_star_or_key", LVT_FUNCTION, (size_t) "interact_star_or_key", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_strong_wind", LVT_FUNCTION, (size_t) "interact_strong_wind", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_text", LVT_FUNCTION, (size_t) "interact_text", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_tornado", LVT_FUNCTION, (size_t) "interact_tornado", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_warp", LVT_FUNCTION, (size_t) "interact_warp", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_warp_door", LVT_FUNCTION, (size_t) "interact_warp_door", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_water_ring", LVT_FUNCTION, (size_t) "interact_water_ring", true, LOT_NONE, 1, sizeof(const char *) },
{ "interact_whirlpool", LVT_FUNCTION, (size_t) "interact_whirlpool", true, LOT_NONE, 1, sizeof(const char *) },
{ "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 *) },

630
src/pc/lua/smlua_functions_autogen.c
View file

@ -14330,6 +14330,26 @@ int smlua_func_interact_coin(lua_State* L) {
return 1;
}
int smlua_func_interact_coin_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_coin", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_coin"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_coin"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_COIN, o, interact_coin));
return 1;
}
int smlua_func_interact_water_ring(lua_State* L) {
if (L == NULL) { return 0; }
@ -14350,6 +14370,26 @@ int smlua_func_interact_water_ring(lua_State* L) {
return 1;
}
int smlua_func_interact_water_ring_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_water_ring", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_water_ring"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_water_ring"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_WATER_RING, o, interact_water_ring));
return 1;
}
int smlua_func_interact_star_or_key(lua_State* L) {
if (L == NULL) { return 0; }
@ -14370,6 +14410,26 @@ int smlua_func_interact_star_or_key(lua_State* L) {
return 1;
}
int smlua_func_interact_star_or_key_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_star_or_key", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_star_or_key"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_star_or_key"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_STAR_OR_KEY, o, interact_star_or_key));
return 1;
}
int smlua_func_interact_bbh_entrance(lua_State* L) {
if (L == NULL) { return 0; }
@ -14390,6 +14450,26 @@ int smlua_func_interact_bbh_entrance(lua_State* L) {
return 1;
}
int smlua_func_interact_bbh_entrance_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_bbh_entrance", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_bbh_entrance"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_bbh_entrance"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_BBH_ENTRANCE, o, interact_bbh_entrance));
return 1;
}
int smlua_func_interact_warp(lua_State* L) {
if (L == NULL) { return 0; }
@ -14410,6 +14490,26 @@ int smlua_func_interact_warp(lua_State* L) {
return 1;
}
int smlua_func_interact_warp_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_warp", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_warp"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_warp"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_WARP, o, interact_warp));
return 1;
}
int smlua_func_interact_warp_door(lua_State* L) {
if (L == NULL) { return 0; }
@ -14430,6 +14530,26 @@ int smlua_func_interact_warp_door(lua_State* L) {
return 1;
}
int smlua_func_interact_warp_door_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_warp_door", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_warp_door"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_warp_door"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_WARP_DOOR, o, interact_warp_door));
return 1;
}
int smlua_func_interact_door(lua_State* L) {
if (L == NULL) { return 0; }
@ -14450,6 +14570,26 @@ int smlua_func_interact_door(lua_State* L) {
return 1;
}
int smlua_func_interact_door_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_door", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_door"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_door"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_DOOR, o, interact_door));
return 1;
}
int smlua_func_interact_cannon_base(lua_State* L) {
if (L == NULL) { return 0; }
@ -14470,6 +14610,26 @@ int smlua_func_interact_cannon_base(lua_State* L) {
return 1;
}
int smlua_func_interact_cannon_base_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_cannon_base", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_cannon_base"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_cannon_base"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_CANNON_BASE, o, interact_cannon_base));
return 1;
}
int smlua_func_interact_player(lua_State* L) {
if (L == NULL) { return 0; }
@ -14490,6 +14650,26 @@ int smlua_func_interact_player(lua_State* L) {
return 1;
}
int smlua_func_interact_player_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_player", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_player"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_player"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_PLAYER, o, interact_player));
return 1;
}
int smlua_func_interact_igloo_barrier(lua_State* L) {
if (L == NULL) { return 0; }
@ -14510,6 +14690,26 @@ int smlua_func_interact_igloo_barrier(lua_State* L) {
return 1;
}
int smlua_func_interact_igloo_barrier_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_igloo_barrier", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_igloo_barrier"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_igloo_barrier"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_IGLOO_BARRIER, o, interact_igloo_barrier));
return 1;
}
int smlua_func_interact_tornado(lua_State* L) {
if (L == NULL) { return 0; }
@ -14530,6 +14730,26 @@ int smlua_func_interact_tornado(lua_State* L) {
return 1;
}
int smlua_func_interact_tornado_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_tornado", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_tornado"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_tornado"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_TORNADO, o, interact_tornado));
return 1;
}
int smlua_func_interact_whirlpool(lua_State* L) {
if (L == NULL) { return 0; }
@ -14550,6 +14770,26 @@ int smlua_func_interact_whirlpool(lua_State* L) {
return 1;
}
int smlua_func_interact_whirlpool_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_whirlpool", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_whirlpool"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_whirlpool"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_WHIRLPOOL, o, interact_whirlpool));
return 1;
}
int smlua_func_interact_strong_wind(lua_State* L) {
if (L == NULL) { return 0; }
@ -14570,6 +14810,26 @@ int smlua_func_interact_strong_wind(lua_State* L) {
return 1;
}
int smlua_func_interact_strong_wind_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_strong_wind", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_strong_wind"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_strong_wind"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_STRONG_WIND, o, interact_strong_wind));
return 1;
}
int smlua_func_interact_flame(lua_State* L) {
if (L == NULL) { return 0; }
@ -14590,6 +14850,26 @@ int smlua_func_interact_flame(lua_State* L) {
return 1;
}
int smlua_func_interact_flame_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_flame", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_flame"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_flame"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_FLAME, o, interact_flame));
return 1;
}
int smlua_func_interact_snufit_bullet(lua_State* L) {
if (L == NULL) { return 0; }
@ -14610,6 +14890,26 @@ int smlua_func_interact_snufit_bullet(lua_State* L) {
return 1;
}
int smlua_func_interact_snufit_bullet_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_snufit_bullet", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_snufit_bullet"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_snufit_bullet"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_SNUFIT_BULLET, o, interact_snufit_bullet));
return 1;
}
int smlua_func_interact_clam_or_bubba(lua_State* L) {
if (L == NULL) { return 0; }
@ -14630,6 +14930,26 @@ int smlua_func_interact_clam_or_bubba(lua_State* L) {
return 1;
}
int smlua_func_interact_clam_or_bubba_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_clam_or_bubba", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_clam_or_bubba"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_clam_or_bubba"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_CLAM_OR_BUBBA, o, interact_clam_or_bubba));
return 1;
}
int smlua_func_interact_bully(lua_State* L) {
if (L == NULL) { return 0; }
@ -14650,6 +14970,26 @@ int smlua_func_interact_bully(lua_State* L) {
return 1;
}
int smlua_func_interact_bully_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_bully", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_bully"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_bully"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_BULLY, o, interact_bully));
return 1;
}
int smlua_func_interact_shock(lua_State* L) {
if (L == NULL) { return 0; }
@ -14670,6 +15010,26 @@ int smlua_func_interact_shock(lua_State* L) {
return 1;
}
int smlua_func_interact_shock_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_shock", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_shock"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_shock"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_SHOCK, o, interact_shock));
return 1;
}
int smlua_func_interact_mr_blizzard(lua_State* L) {
if (L == NULL) { return 0; }
@ -14690,6 +15050,26 @@ int smlua_func_interact_mr_blizzard(lua_State* L) {
return 1;
}
int smlua_func_interact_mr_blizzard_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_mr_blizzard", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_mr_blizzard"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_mr_blizzard"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_MR_BLIZZARD, o, interact_mr_blizzard));
return 1;
}
int smlua_func_interact_hit_from_below(lua_State* L) {
if (L == NULL) { return 0; }
@ -14710,6 +15090,26 @@ int smlua_func_interact_hit_from_below(lua_State* L) {
return 1;
}
int smlua_func_interact_hit_from_below_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_hit_from_below", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_hit_from_below"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_hit_from_below"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_HIT_FROM_BELOW, o, interact_hit_from_below));
return 1;
}
int smlua_func_interact_bounce_top(lua_State* L) {
if (L == NULL) { return 0; }
@ -14730,6 +15130,26 @@ int smlua_func_interact_bounce_top(lua_State* L) {
return 1;
}
int smlua_func_interact_bounce_top_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_bounce_top", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_bounce_top"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_bounce_top"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_BOUNCE_TOP, o, interact_bounce_top));
return 1;
}
int smlua_func_interact_spiny_walking(lua_State* L) {
if (L == NULL) { return 0; }
@ -14750,6 +15170,26 @@ int smlua_func_interact_spiny_walking(lua_State* L) {
return 1;
}
int smlua_func_interact_spiny_walking_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_spiny_walking", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_spiny_walking"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_spiny_walking"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_SPINY_WALKING, o, interact_spiny_walking));
return 1;
}
int smlua_func_interact_damage(lua_State* L) {
if (L == NULL) { return 0; }
@ -14770,6 +15210,26 @@ int smlua_func_interact_damage(lua_State* L) {
return 1;
}
int smlua_func_interact_damage_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_damage", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_damage"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_damage"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_DAMAGE, o, interact_damage));
return 1;
}
int smlua_func_interact_breakable(lua_State* L) {
if (L == NULL) { return 0; }
@ -14790,6 +15250,26 @@ int smlua_func_interact_breakable(lua_State* L) {
return 1;
}
int smlua_func_interact_breakable_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_breakable", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_breakable"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_breakable"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_BREAKABLE, o, interact_breakable));
return 1;
}
int smlua_func_interact_koopa_shell(lua_State* L) {
if (L == NULL) { return 0; }
@ -14810,6 +15290,26 @@ int smlua_func_interact_koopa_shell(lua_State* L) {
return 1;
}
int smlua_func_interact_koopa_shell_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_koopa_shell", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_koopa_shell"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_koopa_shell"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_KOOPA_SHELL, o, interact_koopa_shell));
return 1;
}
int smlua_func_interact_pole(lua_State* L) {
if (L == NULL) { return 0; }
@ -14830,6 +15330,26 @@ int smlua_func_interact_pole(lua_State* L) {
return 1;
}
int smlua_func_interact_pole_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_pole", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_pole"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_pole"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_POLE, o, interact_pole));
return 1;
}
int smlua_func_interact_hoot(lua_State* L) {
if (L == NULL) { return 0; }
@ -14850,6 +15370,26 @@ int smlua_func_interact_hoot(lua_State* L) {
return 1;
}
int smlua_func_interact_hoot_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_hoot", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_hoot"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_hoot"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_HOOT, o, interact_hoot));
return 1;
}
int smlua_func_interact_cap(lua_State* L) {
if (L == NULL) { return 0; }
@ -14870,6 +15410,26 @@ int smlua_func_interact_cap(lua_State* L) {
return 1;
}
int smlua_func_interact_cap_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_cap", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_cap"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_cap"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_CAP, o, interact_cap));
return 1;
}
int smlua_func_interact_grabbable(lua_State* L) {
if (L == NULL) { return 0; }
@ -14890,6 +15450,26 @@ int smlua_func_interact_grabbable(lua_State* L) {
return 1;
}
int smlua_func_interact_grabbable_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_grabbable", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_grabbable"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_grabbable"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_GRABBABLE, o, interact_grabbable));
return 1;
}
int smlua_func_interact_text(lua_State* L) {
if (L == NULL) { return 0; }
@ -14910,6 +15490,26 @@ int smlua_func_interact_text(lua_State* L) {
return 1;
}
int smlua_func_interact_text_SPOOFED(lua_State* L) {
if (L == NULL) { return 0; }
int top = lua_gettop(L);
if (top != 3) {
LOG_LUA_LINE("Improper param count for '%s': Expected %u, Received %u", "interact_text", 3, top);
return 0;
}
struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 1, "interact_text"); return 0; }
// interactType skipped so mods can't lie about what interaction it is
struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 3, "interact_text"); return 0; }
lua_pushinteger(L, process_interaction(m, INTERACT_TEXT, o, interact_text));
return 1;
}
int smlua_func_mario_obj_angle_to_object(lua_State* L) {
if (L == NULL) { return 0; }
@ -37850,35 +38450,65 @@ void smlua_bind_functions_autogen(void) {
// interaction.h
smlua_bind_function(L, "interact_coin", smlua_func_interact_coin);
smlua_bind_function(L, "interact_coin_SPOOFED", smlua_func_interact_coin_SPOOFED);
smlua_bind_function(L, "interact_water_ring", smlua_func_interact_water_ring);
smlua_bind_function(L, "interact_water_ring_SPOOFED", smlua_func_interact_water_ring_SPOOFED);
smlua_bind_function(L, "interact_star_or_key", smlua_func_interact_star_or_key);
smlua_bind_function(L, "interact_star_or_key_SPOOFED", smlua_func_interact_star_or_key_SPOOFED);
smlua_bind_function(L, "interact_bbh_entrance", smlua_func_interact_bbh_entrance);
smlua_bind_function(L, "interact_bbh_entrance_SPOOFED", smlua_func_interact_bbh_entrance_SPOOFED);
smlua_bind_function(L, "interact_warp", smlua_func_interact_warp);
smlua_bind_function(L, "interact_warp_SPOOFED", smlua_func_interact_warp_SPOOFED);
smlua_bind_function(L, "interact_warp_door", smlua_func_interact_warp_door);
smlua_bind_function(L, "interact_warp_door_SPOOFED", smlua_func_interact_warp_door_SPOOFED);
smlua_bind_function(L, "interact_door", smlua_func_interact_door);
smlua_bind_function(L, "interact_door_SPOOFED", smlua_func_interact_door_SPOOFED);
smlua_bind_function(L, "interact_cannon_base", smlua_func_interact_cannon_base);
smlua_bind_function(L, "interact_cannon_base_SPOOFED", smlua_func_interact_cannon_base_SPOOFED);
smlua_bind_function(L, "interact_player", smlua_func_interact_player);
smlua_bind_function(L, "interact_player_SPOOFED", smlua_func_interact_player_SPOOFED);
smlua_bind_function(L, "interact_igloo_barrier", smlua_func_interact_igloo_barrier);
smlua_bind_function(L, "interact_igloo_barrier_SPOOFED", smlua_func_interact_igloo_barrier_SPOOFED);
smlua_bind_function(L, "interact_tornado", smlua_func_interact_tornado);
smlua_bind_function(L, "interact_tornado_SPOOFED", smlua_func_interact_tornado_SPOOFED);
smlua_bind_function(L, "interact_whirlpool", smlua_func_interact_whirlpool);
smlua_bind_function(L, "interact_whirlpool_SPOOFED", smlua_func_interact_whirlpool_SPOOFED);
smlua_bind_function(L, "interact_strong_wind", smlua_func_interact_strong_wind);
smlua_bind_function(L, "interact_strong_wind_SPOOFED", smlua_func_interact_strong_wind_SPOOFED);
smlua_bind_function(L, "interact_flame", smlua_func_interact_flame);
smlua_bind_function(L, "interact_flame_SPOOFED", smlua_func_interact_flame_SPOOFED);
smlua_bind_function(L, "interact_snufit_bullet", smlua_func_interact_snufit_bullet);
smlua_bind_function(L, "interact_snufit_bullet_SPOOFED", smlua_func_interact_snufit_bullet_SPOOFED);
smlua_bind_function(L, "interact_clam_or_bubba", smlua_func_interact_clam_or_bubba);
smlua_bind_function(L, "interact_clam_or_bubba_SPOOFED", smlua_func_interact_clam_or_bubba_SPOOFED);
smlua_bind_function(L, "interact_bully", smlua_func_interact_bully);
smlua_bind_function(L, "interact_bully_SPOOFED", smlua_func_interact_bully_SPOOFED);
smlua_bind_function(L, "interact_shock", smlua_func_interact_shock);
smlua_bind_function(L, "interact_shock_SPOOFED", smlua_func_interact_shock_SPOOFED);
smlua_bind_function(L, "interact_mr_blizzard", smlua_func_interact_mr_blizzard);
smlua_bind_function(L, "interact_mr_blizzard_SPOOFED", smlua_func_interact_mr_blizzard_SPOOFED);
smlua_bind_function(L, "interact_hit_from_below", smlua_func_interact_hit_from_below);
smlua_bind_function(L, "interact_hit_from_below_SPOOFED", smlua_func_interact_hit_from_below_SPOOFED);
smlua_bind_function(L, "interact_bounce_top", smlua_func_interact_bounce_top);
smlua_bind_function(L, "interact_bounce_top_SPOOFED", smlua_func_interact_bounce_top_SPOOFED);
smlua_bind_function(L, "interact_spiny_walking", smlua_func_interact_spiny_walking);
smlua_bind_function(L, "interact_spiny_walking_SPOOFED", smlua_func_interact_spiny_walking_SPOOFED);
smlua_bind_function(L, "interact_damage", smlua_func_interact_damage);
smlua_bind_function(L, "interact_damage_SPOOFED", smlua_func_interact_damage_SPOOFED);
smlua_bind_function(L, "interact_breakable", smlua_func_interact_breakable);
smlua_bind_function(L, "interact_breakable_SPOOFED", smlua_func_interact_breakable_SPOOFED);
smlua_bind_function(L, "interact_koopa_shell", smlua_func_interact_koopa_shell);
smlua_bind_function(L, "interact_koopa_shell_SPOOFED", smlua_func_interact_koopa_shell_SPOOFED);
smlua_bind_function(L, "interact_pole", smlua_func_interact_pole);
smlua_bind_function(L, "interact_pole_SPOOFED", smlua_func_interact_pole_SPOOFED);
smlua_bind_function(L, "interact_hoot", smlua_func_interact_hoot);
smlua_bind_function(L, "interact_hoot_SPOOFED", smlua_func_interact_hoot_SPOOFED);
smlua_bind_function(L, "interact_cap", smlua_func_interact_cap);
smlua_bind_function(L, "interact_cap_SPOOFED", smlua_func_interact_cap_SPOOFED);
smlua_bind_function(L, "interact_grabbable", smlua_func_interact_grabbable);
smlua_bind_function(L, "interact_grabbable_SPOOFED", smlua_func_interact_grabbable_SPOOFED);
smlua_bind_function(L, "interact_text", smlua_func_interact_text);
smlua_bind_function(L, "interact_text_SPOOFED", smlua_func_interact_text_SPOOFED);
smlua_bind_function(L, "mario_obj_angle_to_object", smlua_func_mario_obj_angle_to_object);
smlua_bind_function(L, "mario_stop_riding_object", smlua_func_mario_stop_riding_object);
smlua_bind_function(L, "mario_grab_used_object", smlua_func_mario_grab_used_object);