diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index d4296d362..6870268fe 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -292,7 +292,6 @@ if(${SRB2_CONFIG_HAVE_BLUA}) lua_script.c lua_skinlib.c lua_thinkerlib.c - lua_udatalib.c lua_glib.c ) set(SRB2_LUA_HEADERS @@ -302,7 +301,6 @@ if(${SRB2_CONFIG_HAVE_BLUA}) lua_profile.h lua_libs.h lua_script.h - lua_udatalib.h lua_glib.h ) diff --git a/src/Sourcefile b/src/Sourcefile index f09a143bd..375197e7e 100644 --- a/src/Sourcefile +++ b/src/Sourcefile @@ -97,6 +97,5 @@ lua_playerlib.c lua_script.c lua_skinlib.c lua_thinkerlib.c -lua_udatalib.c lua_glib.c lua_profile.cpp diff --git a/src/lua_maplib.c b/src/lua_maplib.c index 87639b77b..4a913ed55 100644 --- a/src/lua_maplib.c +++ b/src/lua_maplib.c @@ -18,7 +18,6 @@ #include "p_slopes.h" #include "r_main.h" -#include "lua_udatalib.h" #include "lua_script.h" #include "lua_libs.h" #include "lua_hud.h" // hud_running errors @@ -256,15 +255,6 @@ static const char *const vector_opt[] = { static const char *const array_opt[] ={"iterate",NULL}; static const char *const valid_opt[] ={"valid",NULL}; -#define pushsubsector(L, subsector) LUA_PushUserdata(L, subsector, META_SUBSECTOR) -int udatalib_getter_subsector(lua_State *L) -UDATALIB_SIMPLE_GETTER(subsector_t*, pushsubsector) -#undef pushsubsector - -#define pushslope(L, slope) LUA_PushUserdata(L, slope, META_SLOPE) -int udatalib_getter_slope(lua_State *L) -UDATALIB_SIMPLE_GETTER(pslope_t*, pushslope) -#undef pushslope // iterates through a sector's thinglist! static int lib_iterateSectorThinglist(lua_State *L) { diff --git a/src/lua_mobjlib.c b/src/lua_mobjlib.c index 9bd5f5203..a8253c028 100644 --- a/src/lua_mobjlib.c +++ b/src/lua_mobjlib.c @@ -28,712 +28,381 @@ #include "lua_hud.h" // hud_running errors #include "lua_hook.h" // cmd errors -#include "lua_udatalib.h" +#define MOBJ_FIELDS(X) \ + X(valid) \ + X(x) \ + X(y) \ + X(z) \ + X(snext) \ + X(sprev) \ + X(angle) \ + X(pitch) \ + X(roll) \ + X(rollangle) \ + X(sloperoll) \ + X(slopepitch) \ + X(rollsum) \ + X(sprite) \ + X(frame) \ + X(anim_duration) \ + X(spritexscale) \ + X(spriteyscale) \ + X(spritexoffset) \ + X(spriteyoffset) \ + X(touching_sectorlist) \ + X(lightlevel) \ + X(subsector) \ + X(floorz) \ + X(ceilingz) \ + X(radius) \ + X(height) \ + X(momx) \ + X(momy) \ + X(momz) \ + X(pmomz) \ + X(tics) \ + X(state) \ + X(flags) \ + X(flags2) \ + X(eflags) \ + X(skin) \ + X(localskin) \ + X(color) \ + X(blendmode) \ + X(bnext) \ + X(bprev) \ + X(hnext) \ + X(hprev) \ + X(type) \ + X(info) \ + X(health) \ + X(movedir) \ + X(movecount) \ + X(target) \ + X(reactiontime) \ + X(threshold) \ + X(player) \ + X(lastlook) \ + X(spawnpoint) \ + X(tracer) \ + X(friction) \ + X(movefactor) \ + X(fuse) \ + X(watertop) \ + X(waterbottom) \ + X(mobjnum) \ + X(scale) \ + X(destscale) \ + X(scalespeed) \ + X(extravalue1) \ + X(extravalue2) \ + X(cusval) \ + X(cvmem) \ + X(standingslope) \ + X(colorized) \ + X(mirrored) \ + X(islocal) -int mobj_nosetpos_x(lua_State *L); -int mobj_nosetpos_y(lua_State *L); -int mobj_nosetpos_subsector(lua_State *L); -int mobj_nosetpos_floorz(lua_State *L); -int mobj_nosetpos_ceilingz(lua_State *L); -int mobj_snext_noset(lua_State *L); -int mobj_z_setter(lua_State *L); -int mobj_sprev_unimplemented(lua_State *L); -int mobj_angle_setter(lua_State *L); -int mobj_sloperoll_noop(lua_State *L); -int mobj_spritescale_setter(lua_State *L); -int mobj_spriteoffset_setter(lua_State *L); -int mobj_touching_sectorlist_unimplemented(lua_State *L); -int mobj_radius_setter(lua_State *L); -int mobj_height_setter(lua_State *L); -int mobj_pmomz_setter(lua_State *L); -int mobj_state_getter(lua_State *L); -int mobj_state_setter(lua_State *L); -int mobj_flags_setter(lua_State *L); -int mobj_skin_getter(lua_State *L); -int mobj_skin_setter(lua_State *L); -int mobj_localskin_getter(lua_State *L); -int mobj_localskin_setter(lua_State *L); -int mobj_color_setter(lua_State *L); -int mobj_blendmode_setter(lua_State *L); -int mobj_bnext_noset(lua_State *L); -int mobj_bprev_unimplemented(lua_State *L); -int mobj_hnext_setter(lua_State *L); -int mobj_hprev_setter(lua_State *L); -int mobj_type_setter(lua_State *L); -int mobj_info_getter(lua_State *L); -int mobj_info_noset(lua_State *L); -int mobj_target_getter(lua_State *L); -int mobj_target_setter(lua_State *L); -int mobj_player_noset(lua_State *L); -int mobj_spawnpoint_setter(lua_State *L); -int mobj_tracer_getter(lua_State *L); -int mobj_tracer_setter(lua_State *L); -int mobj_mobjnum_unimplemented(lua_State *L); -int mobj_scale_setter(lua_State *L); -int mobj_destscale_setter(lua_State *L); -int mobj_standingslope_noset(lua_State *L); -int mobj_rollsum_getter(lua_State *L); -int mobj_rollsum_noset(lua_State *L); +enum mobj_e { +#define ENUMITEM(name) mobj_##name, + MOBJ_FIELDS(ENUMITEM) +#undef ENUMITEM + NUMMOBJFIELDS, +}; + +static const char *mobj_opt[] = { +#define STRITEM(name) (#name), + MOBJ_FIELDS(STRITEM) + NULL, +#undef STRITEM +}; + +static int mobj_fields_ref = LUA_NOREF; static const char *const array_opt[] ={"iterate",NULL}; -#define FIELD(type, field_name, getter, setter) { #field_name, offsetof(type, field_name), getter, setter } -static const udata_field_t mobj_fields[] = { - FIELD(mobj_t, x, udatalib_getter_fixed, mobj_nosetpos_x), - FIELD(mobj_t, y, udatalib_getter_fixed, mobj_nosetpos_y), - FIELD(mobj_t, z, udatalib_getter_fixed, mobj_z_setter), - FIELD(mobj_t, snext, udatalib_getter_mobj, mobj_snext_noset), - FIELD(mobj_t, sprev, mobj_sprev_unimplemented, mobj_sprev_unimplemented), - FIELD(mobj_t, angle, udatalib_getter_angle, mobj_angle_setter), - FIELD(mobj_t, pitch, udatalib_getter_angle, udatalib_setter_angle), - FIELD(mobj_t, roll, udatalib_getter_angle, udatalib_setter_angle), - FIELD(mobj_t, rollangle, udatalib_getter_angle, udatalib_setter_angle), - FIELD(mobj_t, sloperoll, udatalib_getter_angle, mobj_sloperoll_noop), - FIELD(mobj_t, slopepitch, udatalib_getter_angle, mobj_sloperoll_noop), - // Macro fails here - { "rollsum", 0, mobj_rollsum_getter, mobj_rollsum_noset }, - FIELD(mobj_t, sprite, udatalib_getter_spritenum, udatalib_setter_spritenum), - FIELD(mobj_t, frame, udatalib_getter_uint32, udatalib_setter_uint32), - FIELD(mobj_t, anim_duration, udatalib_getter_uint16, udatalib_setter_uint16), - FIELD(mobj_t, spritexscale, udatalib_getter_fixed, mobj_spritescale_setter), - FIELD(mobj_t, spriteyscale, udatalib_getter_fixed, mobj_spritescale_setter), - FIELD(mobj_t, spritexoffset, udatalib_getter_fixed, mobj_spriteoffset_setter), - FIELD(mobj_t, spriteyoffset, udatalib_getter_fixed, mobj_spriteoffset_setter), - FIELD(mobj_t, touching_sectorlist, mobj_touching_sectorlist_unimplemented, mobj_touching_sectorlist_unimplemented), - FIELD(mobj_t, lightlevel, udatalib_getter_int16, udatalib_setter_int16), - FIELD(mobj_t, subsector, udatalib_getter_subsector, mobj_nosetpos_subsector), - FIELD(mobj_t, floorz, udatalib_getter_fixed, mobj_nosetpos_floorz), - FIELD(mobj_t, ceilingz, udatalib_getter_fixed, mobj_nosetpos_ceilingz), - FIELD(mobj_t, radius, udatalib_getter_fixed, mobj_radius_setter), - FIELD(mobj_t, height, udatalib_getter_fixed, mobj_height_setter), - FIELD(mobj_t, momx, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(mobj_t, momy, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(mobj_t, momz, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(mobj_t, pmomz, udatalib_getter_fixed, mobj_pmomz_setter), - FIELD(mobj_t, tics, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, state, mobj_state_getter, mobj_state_setter), - FIELD(mobj_t, flags, udatalib_getter_uint32, mobj_flags_setter), - FIELD(mobj_t, flags2, udatalib_getter_uint32, udatalib_setter_uint32), - FIELD(mobj_t, eflags, udatalib_getter_uint32, udatalib_setter_uint32), - FIELD(mobj_t, skin, mobj_skin_getter, mobj_skin_setter), - FIELD(mobj_t, localskin, mobj_localskin_getter, mobj_localskin_setter), - FIELD(mobj_t, color, udatalib_getter_uint8, mobj_color_setter), - FIELD(mobj_t, blendmode, udatalib_getter_int32, mobj_blendmode_setter), - FIELD(mobj_t, bnext, udatalib_getter_mobj, mobj_bnext_noset), - FIELD(mobj_t, bprev, mobj_bprev_unimplemented, mobj_bprev_unimplemented), - FIELD(mobj_t, hnext, udatalib_getter_mobj, mobj_hnext_setter), - FIELD(mobj_t, hprev, udatalib_getter_mobj, mobj_hprev_setter), - FIELD(mobj_t, type, udatalib_getter_mobjtype, mobj_type_setter), - FIELD(mobj_t, info, mobj_info_getter, mobj_info_noset), - FIELD(mobj_t, health, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, movedir, udatalib_getter_angle, udatalib_setter_angle), // Differs a bit from original setter and getter - FIELD(mobj_t, movecount, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, target, mobj_target_getter, mobj_target_setter), - FIELD(mobj_t, reactiontime, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, threshold, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, player, udatalib_getter_player, mobj_player_noset), - FIELD(mobj_t, lastlook, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, spawnpoint, udatalib_getter_mapthing, mobj_spawnpoint_setter), - FIELD(mobj_t, tracer, mobj_tracer_getter, mobj_tracer_setter), - FIELD(mobj_t, friction, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(mobj_t, movefactor, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(mobj_t, fuse, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, watertop, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(mobj_t, waterbottom, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(mobj_t, mobjnum, mobj_mobjnum_unimplemented, mobj_mobjnum_unimplemented), - FIELD(mobj_t, scale, udatalib_getter_fixed, mobj_scale_setter), - FIELD(mobj_t, destscale, udatalib_getter_fixed, mobj_destscale_setter), - FIELD(mobj_t, scalespeed, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(mobj_t, extravalue1, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, extravalue2, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, cusval, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, cvmem, udatalib_getter_int32, udatalib_setter_int32), - FIELD(mobj_t, standingslope, udatalib_getter_slope, mobj_standingslope_noset), - FIELD(mobj_t, colorized, udatalib_getter_boolean, udatalib_setter_boolean), - FIELD(mobj_t, mirrored, udatalib_getter_boolean, udatalib_setter_boolean), - FIELD(mobj_t, islocal, udatalib_getter_boolean, udatalib_setter_boolean), - { NULL, 0, NULL, NULL }, -}; -#undef FIELD - -// First, implement udatalib simple getters -#define pushmobj(L, mobj) LUA_PushUserdata(L, mobj, META_MOBJ) -int udatalib_getter_mobj(lua_State *L) -UDATALIB_SIMPLE_GETTER(mobj_t*, pushmobj) -#undef pushmobj - -int udatalib_getter_mobjtype(lua_State *L) -UDATALIB_SIMPLE_GETTER(mobjtype_t, lua_pushinteger) - -#define pushmapthing(L, mapthing) LUA_PushUserdata(L, mapthing, META_MAPTHING) -int udatalib_getter_mapthing(lua_State *L) -UDATALIB_SIMPLE_GETTER(mapthing_t*, pushmapthing) -#undef pushmapthing - -// Now specific fields related to mobj positions that cannot be set directly -#define NOSETPOS(field) \ -int mobj_nosetpos_ ## field(lua_State *L) \ -{ \ - return luaL_error(L, LUA_QL("mobj_t") " field " LUA_QS " should not be set directly. Use " LUA_QL("P_Move") ", " LUA_QL("P_TryMove") ", or " LUA_QL("P_SetOrigin") ", or " LUA_QL("P_MoveOrigin") " instead.", #field); \ -} - -NOSETPOS(x) -NOSETPOS(y) -NOSETPOS(subsector) -NOSETPOS(floorz) -NOSETPOS(ceilingz) - -#undef NOSETPOS - -// Other fields that cannot be set directly -#define NOSET(field) \ -int mobj_ ## field ## _noset(lua_State *L) \ -{ \ - return luaL_error(L, LUA_QL("mobj_t") " field " LUA_QS " should not be set directly.", #field); \ -} - -#define NOSET_USE(field, use) \ -int mobj_ ## field ## _noset(lua_State *L) \ -{ \ - return luaL_error(L, LUA_QL("mobj_t") " field " LUA_QS " should not be set directly. Use " LUA_QL(use) " instead.", #field); \ -} - -NOSET(snext) -NOSET(bnext) -NOSET(info) -NOSET(player) -NOSET(standingslope) -NOSET_USE(rollsum, "rollangle") - -#undef NOSET -#undef NOSET_USE - -// Unimplemented fields (why would you need to set them like that explicitly? -// No idea, i'm keeping it for synch reasons) -#define UNIMPLEMENTED(field) \ -int mobj_ ## field ## _unimplemented(lua_State *L) \ -{ \ - return luaL_error(L, LUA_QL("mobj_t") " field " LUA_QS " is not implemented for Lua and cannot be accessed.", #field); \ -} - -UNIMPLEMENTED(sprev) -UNIMPLEMENTED(touching_sectorlist) -UNIMPLEMENTED(bprev) -UNIMPLEMENTED(mobjnum) - -#undef UNIMPLEMENTED - -// For some dumb reason it is valid to set sloperoll, even though it is read -// only -int mobj_sloperoll_noop(lua_State *L) { (void)L; return 0; } - -// Now other getters/setters with arbitary logic - -// Getters get light userdata, which in this case is just mobj_t pointer -#define GETMO() (mobj_t*)lua_touserdata(L, 1) - -int mobj_z_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - // z doesn't cross sector bounds so it's okay. - mobj_t *ptmthing = tmthing; - mo->z = luaL_checkfixed(L, 2); - P_CheckPosition(mo, mo->x, mo->y); - mo->floorz = tmfloorz; - mo->ceilingz = tmceilingz; - P_SetTarget(&tmthing, ptmthing); - - return 0; -} - -int mobj_angle_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - mo->angle = luaL_checkangle(L, 2); - if (mo->player) - P_ForceLocalAngle(mo->player, mo->angle); - - return 0; -} - -int mobj_spritescale_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - fixed_t *spritescale; - UDATALIB_GETFIELD(fixed_t, spritescale); - - if (!mo->player) - *spritescale = luaL_checkfixed(L, 2); - else - { - // Mmm yea - if (spritescale == &mo->spritexscale) - mo->realxscale = luaL_checkfixed(L, 2); - else - mo->realyscale = luaL_checkfixed(L, 2); - } - return 0; -} - -int mobj_spriteoffset_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - fixed_t *spriteoffset; - UDATALIB_GETFIELD(fixed_t, spriteoffset); - - if (!mo->player) - *spriteoffset = luaL_checkfixed(L, 2); - else - { - // Mmm yea - if (spriteoffset == &mo->spritexoffset) - mo->realxoffset = luaL_checkfixed(L, 2); - else - mo->realyoffset = luaL_checkfixed(L, 2); - } - return 0; -} - -int mobj_radius_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - mobj_t *ptmthing = tmthing; - mo->radius = luaL_checkfixed(L, 2); - if (mo->radius < 0) - mo->radius = 0; - P_CheckPosition(mo, mo->x, mo->y); - mo->floorz = tmfloorz; - mo->ceilingz = tmceilingz; - P_SetTarget(&tmthing, ptmthing); - - return 0; -} - -int mobj_height_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - mobj_t *ptmthing = tmthing; - mo->height = luaL_checkfixed(L, 2); - if (mo->height < 0) - mo->height = 0; - P_CheckPosition(mo, mo->x, mo->y); - mo->floorz = tmfloorz; - mo->ceilingz = tmceilingz; - P_SetTarget(&tmthing, ptmthing); - - return 0; -} - -int mobj_pmomz_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - mo->pmomz = luaL_checkfixed(L, 2); - mo->eflags |= MFE_APPLYPMOMZ; - - return 0; -} - -int mobj_state_getter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - lua_pushinteger(L, mo->state-states); - - return 1; -} - -int mobj_state_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (mo->player) - P_SetPlayerMobjState(mo, luaL_checkinteger(L, 2)); - else - P_SetMobjState(mo, luaL_checkinteger(L, 2)); - - return 0; -} - -int mobj_flags_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - UINT32 flags = luaL_checkinteger(L, 2); - if ((flags & (MF_NOBLOCKMAP|MF_NOSECTOR)) != (mo->flags & (MF_NOBLOCKMAP|MF_NOSECTOR))) - { - P_UnsetThingPosition(mo); - mo->flags = flags; - if (flags & MF_NOSECTOR && sector_list) - { - P_DelSeclist(sector_list); - sector_list = NULL; - } - mo->snext = NULL, mo->sprev = NULL; - mo->bnext = NULL, mo->bprev = NULL; - P_SetThingPosition(mo); - } - else - mo->flags = flags; - - return 0; -} - -int mobj_skin_getter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (!mo->skin) - return 0; - - // HUD ONLY!!!!!!!!!! - if (hud_running && cv_luaimmersion.value) - { - lua_pushstring(L, K_GetMobjSkin(mo)->name); - } - else - lua_pushstring(L, ((skin_t *)mo->skin)->name); - - return 1; -} - -int mobj_skin_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - INT32 i; - char skin[SKINNAMESIZE+1]; // all skin names are limited to this length - strlcpy(skin, luaL_checkstring(L, 2), sizeof skin); - strlwr(skin); // all skin names are lowercase - for (i = 0; i < numskins; i++) - { - if (fastcmp(skins[i].name, skin)) - { - mo->skin = &skins[i]; - return 0; - } - } - - return luaL_error(L, "mobj.skin '%s' not found!", skin); -} - -int mobj_localskin_getter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (mo->localskin) - lua_pushstring(L, ((skin_t *)mo->localskin)->name); - else - lua_pushnil(L); - - return 1; -} - -int mobj_localskin_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (mo->player) - { - SetLocalPlayerSkin(mo->player - players, luaL_optstring(L, 2, "none"), NULL); - } - else - { - INT32 i; - char skin[SKINNAMESIZE+1]; // all skin names are limited to this length - strlcpy(skin, luaL_optstring(L, 2, "none"), sizeof skin); - strlwr(skin); // all skin names are lowercase - - if (!fasticmp(skin, "none")) - { - // Try localskins - for (i = 0; i < numlocalskins; i++) - { - if (fasticmp(localskins[i].name, skin)) - { - mo->localskin = &localskins[i]; - mo->skinlocal = true; - return 0; - } - } - - // Try other skins - for (i = 0; i < numskins; i++) - { - if (fasticmp(skins[i].name, skin)) - { - mo->localskin = &skins[i]; - mo->skinlocal = false; - return 0; - } - } - } - else - { - mo->localskin = NULL; - mo->skinlocal = false; - } - } - - return 0; -} - -int mobj_color_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - UINT8 newcolor = (UINT8)luaL_checkinteger(L, 2); - if (newcolor >= MAXTRANSLATIONS) - return luaL_error(L, "mobj.color %d out of range (0 - %d).", newcolor, MAXTRANSLATIONS-1); - mo->color = newcolor; - - return 0; -} - -int mobj_blendmode_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - INT32 blendmode = (INT32)luaL_checkinteger(L, 2); - if (blendmode < 0 || blendmode > AST_OVERLAY) - return luaL_error(L, "mobj.blendmode %d out of range (0 - %d).", blendmode, AST_OVERLAY); - mo->blendmode = blendmode; - - return 0; -} - -int mobj_hnext_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (lua_isnil(L, 2)) - P_SetTarget(&mo->hnext, NULL); - else - { - mobj_t *hnext = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ)); - P_SetTarget(&mo->hnext, hnext); - } - - return 0; -} - -int mobj_hprev_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (lua_isnil(L, 2)) - P_SetTarget(&mo->hprev, NULL); - else - { - mobj_t *hprev = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ)); - P_SetTarget(&mo->hprev, hprev); - } - - return 0; -} - -int mobj_type_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - mobjtype_t newtype = luaL_checkinteger(L, 2); - if (newtype >= NUMMOBJTYPES) - return luaL_error(L, "mobj.type %d out of range (0 - %d).", newtype, NUMMOBJTYPES-1); - mo->type = newtype; - mo->info = &mobjinfo[newtype]; - P_SetScale(mo, mo->scale); - - return 0; -} - -int mobj_info_getter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - LUA_PushUserdata(L, &mobjinfo[mo->type], META_MOBJINFO); - - return 1; -} - -int mobj_target_getter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (mo->target && P_MobjWasRemoved(mo->target)) - { // don't put invalid mobj back into Lua. - P_SetTarget(&mo->target, NULL); - return 0; - } - LUA_PushUserdata(L, mo->target, META_MOBJ); - - return 1; -} - -int mobj_target_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (lua_isnil(L, 2)) - P_SetTarget(&mo->target, NULL); - else - { - mobj_t *target = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ)); - P_SetTarget(&mo->target, target); - } - - return 0; -} - -int mobj_spawnpoint_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (lua_isnil(L, 2)) - mo->spawnpoint = NULL; - else - { - mapthing_t *spawnpoint = *((mapthing_t **)luaL_checkudata(L, 2, META_MAPTHING)); - mo->spawnpoint = spawnpoint; - } - - return 0; -} - -int mobj_tracer_getter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (mo->tracer && P_MobjWasRemoved(mo->tracer)) - { // don't put invalid mobj back into Lua. - P_SetTarget(&mo->tracer, NULL); - return 0; - } - LUA_PushUserdata(L, mo->tracer, META_MOBJ); - - return 1; -} - -int mobj_tracer_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - if (lua_isnil(L, 2)) - P_SetTarget(&mo->tracer, NULL); - else - { - mobj_t *tracer = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ)); - P_SetTarget(&mo->tracer, tracer); - } - - return 0; -} - -int mobj_scale_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - fixed_t scale = luaL_checkfixed(L, 2); - if (scale < FRACUNIT/100) - scale = FRACUNIT/100; - mo->destscale = scale; - P_SetScale(mo, scale); - mo->old_scale = scale; - - return 0; -} - -int mobj_destscale_setter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - fixed_t scale = luaL_checkfixed(L, 2); - if (scale < FRACUNIT/100) - scale = FRACUNIT/100; - mo->destscale = scale; - - return 0; -} - -// WARNING: Not synch safe! -// Don't use this field in game logic code! -int mobj_rollsum_getter(lua_State *L) -{ - mobj_t *mo = GETMO(); - - angle_t pitchnroll = P_MobjPitchAndRoll(mo); - - angle_t rollsum = mo->rollangle + pitchnroll; - - if (mo->player) - { - rollsum += R_PlayerSliptideAngle(mo->player); - } - - lua_pushangle(L, rollsum); - - return 1; -} - +#define UNIMPLEMENTED luaL_error(L, LUA_QL("mobj_t") " field " LUA_QS " is not implemented for Lua and cannot be accessed.", mobj_opt[field]) static int mobj_get(lua_State *L) { mobj_t *mo = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ)); - - // We still gonna have 2 strcmp for "valid" field - const char *field = luaL_checkstring(L, 2); - + enum mobj_e field = Lua_optoption(L, 2, -1, mobj_fields_ref); lua_settop(L, 2); if (!mo) { - if (fastcmp(field, "valid")) { + if (field == mobj_valid) { lua_pushboolean(L, 0); return 1; } return LUA_ErrInvalid(L, "mobj_t"); - } else if (fastcmp(field, "valid")) { - lua_pushboolean(L, 1); - return 1; - } + } - lua_getmetatable(L, 1); + switch(field) + { + case mobj_valid: + lua_pushboolean(L, 1); + break; + case mobj_x: + lua_pushfixed(L, mo->x); + break; + case mobj_y: + lua_pushfixed(L, mo->y); + break; + case mobj_z: + lua_pushfixed(L, mo->z); + break; + case mobj_snext: + LUA_PushUserdata(L, mo->snext, META_MOBJ); + break; + case mobj_sprev: + // sprev is actually the previous mobj's snext pointer, + // or the subsector->sector->thing_list if there is no previous mobj, + // i.e. it will always ultimately point to THIS mobj -- so that's actually not useful to Lua and won't be included. + return UNIMPLEMENTED; + case mobj_angle: + lua_pushangle(L, mo->angle); + break; + case mobj_sprite: + lua_pushinteger(L, mo->sprite); + break; + case mobj_frame: + lua_pushinteger(L, mo->frame); + break; + case mobj_anim_duration: + lua_pushinteger(L, mo->anim_duration); + break; + case mobj_touching_sectorlist: + return UNIMPLEMENTED; + case mobj_subsector: + LUA_PushUserdata(L, mo->subsector, META_SUBSECTOR); + break; + case mobj_floorz: + lua_pushfixed(L, mo->floorz); + break; + case mobj_ceilingz: + lua_pushfixed(L, mo->ceilingz); + break; + case mobj_radius: + lua_pushfixed(L, mo->radius); + break; + case mobj_height: + lua_pushfixed(L, mo->height); + break; + case mobj_momx: + lua_pushfixed(L, mo->momx); + break; + case mobj_momy: + lua_pushfixed(L, mo->momy); + break; + case mobj_momz: + lua_pushfixed(L, mo->momz); + break; + case mobj_pmomz: + lua_pushfixed(L, mo->pmomz); + break; + case mobj_tics: + lua_pushinteger(L, mo->tics); + break; + case mobj_state: // state number, not struct + lua_pushinteger(L, mo->state-states); + break; + case mobj_flags: + lua_pushinteger(L, mo->flags); + break; + case mobj_flags2: + lua_pushinteger(L, mo->flags2); + break; + case mobj_eflags: + lua_pushinteger(L, mo->eflags); + break; + case mobj_skin: // skin name or nil, not struct + if (!mo->skin) + return 0; + lua_pushstring(L, ((skin_t *)mo->skin)->name); + break; + case mobj_color: + lua_pushinteger(L, mo->color); + break; + case mobj_bnext: + LUA_PushUserdata(L, mo->bnext, META_MOBJ); + break; + case mobj_bprev: + // bprev -- same deal as sprev above, but for the blockmap. + return UNIMPLEMENTED; + case mobj_hnext: + LUA_PushUserdata(L, mo->hnext, META_MOBJ); + break; + case mobj_hprev: + // implimented differently from sprev and bprev because SSNTails. + LUA_PushUserdata(L, mo->hprev, META_MOBJ); + break; + case mobj_type: + lua_pushinteger(L, mo->type); + break; + case mobj_info: + LUA_PushUserdata(L, &mobjinfo[mo->type], META_MOBJINFO); + break; + case mobj_health: + lua_pushinteger(L, mo->health); + break; + case mobj_movedir: + lua_pushinteger(L, mo->movedir); + break; + case mobj_movecount: + lua_pushinteger(L, mo->movecount); + break; + case mobj_target: + if (mo->target && P_MobjWasRemoved(mo->target)) + { // don't put invalid mobj back into Lua. + P_SetTarget(&mo->target, NULL); + return 0; + } + LUA_PushUserdata(L, mo->target, META_MOBJ); + break; + case mobj_reactiontime: + lua_pushinteger(L, mo->reactiontime); + break; + case mobj_threshold: + lua_pushinteger(L, mo->threshold); + break; + case mobj_player: + LUA_PushUserdata(L, mo->player, META_PLAYER); + break; + case mobj_lastlook: + lua_pushinteger(L, mo->lastlook); + break; + case mobj_spawnpoint: + LUA_PushUserdata(L, mo->spawnpoint, META_MAPTHING); + break; + case mobj_tracer: + if (mo->tracer && P_MobjWasRemoved(mo->tracer)) + { // don't put invalid mobj back into Lua. + P_SetTarget(&mo->tracer, NULL); + return 0; + } + LUA_PushUserdata(L, mo->tracer, META_MOBJ); + break; + case mobj_friction: + lua_pushfixed(L, mo->friction); + break; + case mobj_movefactor: + lua_pushfixed(L, mo->movefactor); + break; + case mobj_fuse: + lua_pushinteger(L, mo->fuse); + break; + case mobj_watertop: + lua_pushfixed(L, mo->watertop); + break; + case mobj_waterbottom: + lua_pushfixed(L, mo->waterbottom); + break; + case mobj_mobjnum: + // mobjnum is a networking thing generated for $$$.sav + // and therefore shouldn't be used by Lua. + return UNIMPLEMENTED; + case mobj_scale: + lua_pushfixed(L, mo->scale); + break; + case mobj_destscale: + lua_pushfixed(L, mo->destscale); + break; + case mobj_scalespeed: + lua_pushfixed(L, mo->scalespeed); + break; + case mobj_extravalue1: + lua_pushinteger(L, mo->extravalue1); + break; + case mobj_extravalue2: + lua_pushinteger(L, mo->extravalue2); + break; + case mobj_cusval: + lua_pushinteger(L, mo->cusval); + break; + case mobj_cvmem: + lua_pushinteger(L, mo->cvmem); + break; + case mobj_standingslope: + LUA_PushUserdata(L, mo->standingslope, META_SLOPE); + break; + case mobj_colorized: + lua_pushboolean(L, mo->colorized); + break; + // Saturn + case mobj_pitch: + lua_pushangle(L, mo->pitch); + break; + case mobj_roll: + lua_pushangle(L, mo->roll); + break; + case mobj_rollangle: + lua_pushangle(L, mo->rollangle); + break; + case mobj_sloperoll: + lua_pushangle(L, mo->sloperoll); + break; + case mobj_slopepitch: + lua_pushangle(L, mo->slopepitch); + break; + case mobj_rollsum: + { + angle_t pitchnroll = P_MobjPitchAndRoll(mo); - lua_pushvalue(L, 2); // Push field name - lua_rawget(L, -2); // Get getter/setter table from metatable + angle_t rollsum = mo->rollangle + pitchnroll; - // If field exists, run getter for it - if (!lua_isnil(L, -1)) { - //CONS_Printf("Running getter for field %s\n", field); - lua_rawgeti(L, -1, UDATALIB_GETTER); - lua_pushlightuserdata(L, mo); - lua_call(L, 1, 1); - //CONS_Printf("Getter returned %s\n", lua_typename(L, lua_type(L, -1))); - return 1; - } + if (mo->player) + { + rollsum += R_PlayerSliptideAngle(mo->player); + } - lua_pop(L, 1); - - //CONS_Printf("Getting custom field %s\n", field); - - // Othervise, return extra value - // extra custom variables in Lua memory - lua_getfield(L, LUA_REGISTRYINDEX, LREG_EXTVARS); - I_Assert(lua_istable(L, -1)); - lua_pushlightuserdata(L, mo); - lua_rawget(L, -2); - if (!lua_istable(L, -1)) { // no extra values table - CONS_Debug(DBG_LUA, M_GetText("'%s' has no extvars table or field named '%s'; returning nil.\n"), "mobj_t", lua_tostring(L, 2)); - return 0; - } - lua_pushvalue(L, 2); // field name - lua_gettable(L, -2); - if (lua_isnil(L, -1)) // no value for this field - CONS_Debug(DBG_LUA, M_GetText("'%s' has no field named '%s'; returning nil.\n"), "mobj_t", lua_tostring(L, 2)); - - return 1; + lua_pushangle(L, rollsum); + break; + } + case mobj_spritexscale: + lua_pushfixed(L, mo->spritexscale); + break; + case mobj_spriteyscale: + lua_pushfixed(L, mo->spriteyscale); + break; + case mobj_spritexoffset: + lua_pushfixed(L, mo->spritexoffset); + break; + case mobj_spriteyoffset: + lua_pushfixed(L, mo->spriteyoffset); + break; + case mobj_lightlevel: + lua_pushinteger(L, mo->lightlevel); + break; + case mobj_localskin: + if (mo->localskin) + lua_pushstring(L, ((skin_t *)mo->localskin)->name); + else + lua_pushnil(L); + break; + case mobj_blendmode: + lua_pushinteger(L, mo->blendmode); + break; + case mobj_mirrored: + lua_pushboolean(L, mo->mirrored); + break; + case mobj_islocal: + lua_pushboolean(L, mo->islocal); + break; + default: // extra custom variables in Lua memory + lua_getfield(L, LUA_REGISTRYINDEX, LREG_EXTVARS); + I_Assert(lua_istable(L, -1)); + lua_pushlightuserdata(L, mo); + lua_rawget(L, -2); + if (!lua_istable(L, -1)) { // no extra values table + CONS_Debug(DBG_LUA, M_GetText("'%s' has no extvars table or field named '%s'; returning nil.\n"), "mobj_t", lua_tostring(L, 2)); + return 0; + } + lua_pushvalue(L, 2); // field name + lua_gettable(L, -2); + if (lua_isnil(L, -1)) // no value for this field + CONS_Debug(DBG_LUA, M_GetText("'%s' has no field named '%s'; returning nil.\n"), "mobj_t", lua_tostring(L, 2)); + break; + } + return 1; } #define NOSET luaL_error(L, LUA_QL("mobj_t") " field " LUA_QS " should not be set directly.", mobj_opt[field]) @@ -741,58 +410,422 @@ static int mobj_get(lua_State *L) static int mobj_set(lua_State *L) { mobj_t *mo = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ)); - - lua_settop(L, 3); + enum mobj_e field = Lua_optoption(L, 2, mobj_valid, mobj_fields_ref);; + lua_settop(L, 3); if (!mo) return LUA_ErrInvalid(L, "mobj_t"); - if (hud_running) - return luaL_error(L, "Do not alter mobj_t in HUD rendering code!"); + if (hud_running) + return luaL_error(L, "Do not alter mobj_t in HUD rendering code!"); - if (hook_cmd_running) - return luaL_error(L, "Do not alter mobj_t in BuildCMD code!"); + if (hook_cmd_running) + return luaL_error(L, "Do not alter mobj_t in BuildCMD code!"); - lua_getmetatable(L, 1); // Push metatable + switch(field) + { + case mobj_valid: + return NOSET; + case mobj_x: + return NOSETPOS; + case mobj_y: + return NOSETPOS; + case mobj_z: + { + // z doesn't cross sector bounds so it's okay. + mobj_t *ptmthing = tmthing; + mo->z = luaL_checkfixed(L, 3); + P_CheckPosition(mo, mo->x, mo->y); + mo->floorz = tmfloorz; + mo->ceilingz = tmceilingz; + P_SetTarget(&tmthing, ptmthing); + break; + } + case mobj_snext: + return NOSETPOS; + case mobj_sprev: + return UNIMPLEMENTED; + case mobj_angle: + mo->angle = luaL_checkangle(L, 3); + if (mo->player == &players[consoleplayer]) + localangle[0] = mo->angle; + else if (mo->player == &players[displayplayers[1]]) + localangle[1] = mo->angle; + else if (mo->player == &players[displayplayers[2]]) + localangle[2] = mo->angle; + else if (mo->player == &players[displayplayers[3]]) + localangle[3] = mo->angle; + break; + case mobj_sprite: + mo->sprite = luaL_checkinteger(L, 3); + break; + case mobj_frame: + mo->frame = (UINT32)luaL_checkinteger(L, 3); + break; + case mobj_anim_duration: + mo->anim_duration = (UINT16)luaL_checkinteger(L, 3); + break; + case mobj_touching_sectorlist: + return UNIMPLEMENTED; + case mobj_subsector: + return NOSETPOS; + case mobj_floorz: + return NOSETPOS; + case mobj_ceilingz: + return NOSETPOS; + case mobj_radius: + { + mobj_t *ptmthing = tmthing; + mo->radius = luaL_checkfixed(L, 3); + if (mo->radius < 0) + mo->radius = 0; + P_CheckPosition(mo, mo->x, mo->y); + mo->floorz = tmfloorz; + mo->ceilingz = tmceilingz; + P_SetTarget(&tmthing, ptmthing); + break; + } + case mobj_height: + { + mobj_t *ptmthing = tmthing; + mo->height = luaL_checkfixed(L, 3); + if (mo->height < 0) + mo->height = 0; + P_CheckPosition(mo, mo->x, mo->y); + mo->floorz = tmfloorz; + mo->ceilingz = tmceilingz; + P_SetTarget(&tmthing, ptmthing); + break; + } + case mobj_momx: + mo->momx = luaL_checkfixed(L, 3); + break; + case mobj_momy: + mo->momy = luaL_checkfixed(L, 3); + break; + case mobj_momz: + mo->momz = luaL_checkfixed(L, 3); + break; + case mobj_pmomz: + mo->pmomz = luaL_checkfixed(L, 3); + mo->eflags |= MFE_APPLYPMOMZ; + break; + case mobj_tics: + mo->tics = luaL_checkinteger(L, 3); + break; + case mobj_state: // set state by enum + if (mo->player) + P_SetPlayerMobjState(mo, luaL_checkinteger(L, 3)); + else + P_SetMobjState(mo, luaL_checkinteger(L, 3)); + break; + case mobj_flags: // special handling for MF_NOBLOCKMAP and MF_NOSECTOR + { + UINT32 flags = luaL_checkinteger(L, 3); + if ((flags & (MF_NOBLOCKMAP|MF_NOSECTOR)) != (mo->flags & (MF_NOBLOCKMAP|MF_NOSECTOR))) + { + P_UnsetThingPosition(mo); + mo->flags = flags; + if (flags & MF_NOSECTOR && sector_list) + { + P_DelSeclist(sector_list); + sector_list = NULL; + } + mo->snext = NULL, mo->sprev = NULL; + mo->bnext = NULL, mo->bprev = NULL; + P_SetThingPosition(mo); + } + else + mo->flags = flags; + break; + } + case mobj_flags2: + mo->flags2 = (UINT32)luaL_checkinteger(L, 3); + break; + case mobj_eflags: + mo->eflags = (UINT32)luaL_checkinteger(L, 3); + break; + case mobj_skin: // set skin by name + { + INT32 i; + char skin[SKINNAMESIZE+1]; // all skin names are limited to this length + strlcpy(skin, luaL_checkstring(L, 3), sizeof skin); + strlwr(skin); // all skin names are lowercase + for (i = 0; i < numskins; i++) + if (fastcmp(skins[i].name, skin)) + { + mo->skin = &skins[i]; + return 0; + } + return luaL_error(L, "mobj.skin '%s' not found!", skin); + } + case mobj_color: + { + UINT8 newcolor = (UINT8)luaL_checkinteger(L,3); + if (newcolor >= MAXTRANSLATIONS) + return luaL_error(L, "mobj.color %d out of range (0 - %d).", newcolor, MAXTRANSLATIONS-1); + mo->color = newcolor; + break; + } + case mobj_bnext: + return NOSETPOS; + case mobj_bprev: + return UNIMPLEMENTED; + case mobj_hnext: + if (lua_isnil(L, 3)) + P_SetTarget(&mo->hnext, NULL); + else + { + mobj_t *hnext = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); + P_SetTarget(&mo->hnext, hnext); + } + break; + case mobj_hprev: + if (lua_isnil(L, 3)) + P_SetTarget(&mo->hprev, NULL); + else + { + mobj_t *hprev = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); + P_SetTarget(&mo->hprev, hprev); + } + break; + case mobj_type: // yeah sure, we'll let you change the mobj's type. + { + mobjtype_t newtype = luaL_checkinteger(L, 3); + if (newtype >= NUMMOBJTYPES) + return luaL_error(L, "mobj.type %d out of range (0 - %d).", newtype, NUMMOBJTYPES-1); + mo->type = newtype; + mo->info = &mobjinfo[newtype]; + P_SetScale(mo, mo->scale); + break; + } + case mobj_info: + return NOSET; + case mobj_health: + mo->health = luaL_checkinteger(L, 3); + break; + case mobj_movedir: + mo->movedir = (angle_t)luaL_checkinteger(L, 3); + break; + case mobj_movecount: + mo->movecount = luaL_checkinteger(L, 3); + break; + case mobj_target: + if (lua_isnil(L, 3)) + P_SetTarget(&mo->target, NULL); + else + { + mobj_t *target = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); + P_SetTarget(&mo->target, target); + } + break; + case mobj_reactiontime: + mo->reactiontime = luaL_checkinteger(L, 3); + break; + case mobj_threshold: + mo->threshold = luaL_checkinteger(L, 3); + break; + case mobj_player: + return NOSET; + case mobj_lastlook: + mo->lastlook = luaL_checkinteger(L, 3); + break; + case mobj_spawnpoint: + if (lua_isnil(L, 3)) + mo->spawnpoint = NULL; + else + { + mapthing_t *spawnpoint = *((mapthing_t **)luaL_checkudata(L, 3, META_MAPTHING)); + mo->spawnpoint = spawnpoint; + } + break; + case mobj_tracer: + if (lua_isnil(L, 3)) + P_SetTarget(&mo->tracer, NULL); + else + { + mobj_t *tracer = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); + P_SetTarget(&mo->tracer, tracer); + } + break; + case mobj_friction: + mo->friction = luaL_checkfixed(L, 3); + break; + case mobj_movefactor: + mo->movefactor = luaL_checkfixed(L, 3); + break; + case mobj_fuse: + mo->fuse = luaL_checkinteger(L, 3); + break; + case mobj_watertop: + mo->watertop = luaL_checkfixed(L, 3); + break; + case mobj_waterbottom: + mo->waterbottom = luaL_checkfixed(L, 3); + break; + case mobj_mobjnum: + return UNIMPLEMENTED; + case mobj_scale: + { + fixed_t scale = luaL_checkfixed(L, 3); + if (scale < FRACUNIT/100) + scale = FRACUNIT/100; + mo->destscale = scale; + P_SetScale(mo, scale); + mo->old_scale = scale; + break; + } + case mobj_destscale: + { + fixed_t scale = luaL_checkfixed(L, 3); + if (scale < FRACUNIT/100) + scale = FRACUNIT/100; + mo->destscale = scale; + break; + } + case mobj_scalespeed: + mo->scalespeed = luaL_checkfixed(L, 3); + break; + case mobj_extravalue1: + mo->extravalue1 = luaL_checkinteger(L, 3); + break; + case mobj_extravalue2: + mo->extravalue2 = luaL_checkinteger(L, 3); + break; + case mobj_cusval: + mo->cusval = luaL_checkinteger(L, 3); + break; + case mobj_cvmem: + mo->cvmem = luaL_checkinteger(L, 3); + break; + case mobj_standingslope: + return NOSET; + case mobj_colorized: + mo->colorized = luaL_checkboolean(L, 3); + break; + case mobj_pitch: + mo->pitch = luaL_checkangle(L, 3); + break; + case mobj_roll: + mo->roll = luaL_checkangle(L, 3); + break; + case mobj_rollangle: + mo->rollangle = luaL_checkangle(L, 3); + break; + case mobj_sloperoll: + case mobj_slopepitch: + //return NOSET; // Thanks to airbrake script, this has to be a noop + break; + case mobj_rollsum: + return NOSET; + break; + case mobj_spritexscale: + if (mo->player) + mo->realxscale = luaL_checkfixed(L, 3); + else + mo->spritexscale = luaL_checkfixed(L, 3); + break; + case mobj_spriteyscale: + if (mo->player) + mo->realyscale = luaL_checkfixed(L, 3); + else + mo->spriteyscale = luaL_checkfixed(L, 3); + break; + case mobj_spritexoffset: + if (mo->player) + mo->realxoffset = luaL_checkfixed(L, 3); + else + mo->spritexoffset = luaL_checkfixed(L, 3); + break; + case mobj_spriteyoffset: + if (mo->player) + mo->realyoffset = luaL_checkfixed(L, 3); + else + mo->spriteyoffset = luaL_checkfixed(L, 3); + break; + case mobj_lightlevel: + mo->lightlevel = (INT16)luaL_checkinteger(L, 3); + break; + case mobj_localskin: + { + if (mo->player) + { + SetLocalPlayerSkin(mo->player - players, luaL_optstring(L, 3, "none"), NULL); + } + else + { + INT32 i; + char skin[SKINNAMESIZE+1]; // all skin names are limited to this length + strlcpy(skin, luaL_optstring(L, 3, "none"), sizeof skin); + strlwr(skin); // all skin names are lowercase - lua_pushvalue(L, 2); // Push field name - lua_rawget(L, -2); // Get getter/setter table from metatable + if (!fasticmp(skin, "none")) + { + // Try localskins + for (i = 0; i < numlocalskins; i++) + { + if (fasticmp(localskins[i].name, skin)) + { + mo->localskin = &localskins[i]; + mo->skinlocal = true; + return 0; + } + } - // If field exists, run setter for it - if (!lua_isnil(L, -1)) { - //CONS_Printf("Running setter for field %s\n", luaL_checkstring(L, 2)); - lua_rawgeti(L, -1, UDATALIB_SETTER); - lua_pushlightuserdata(L, mo); - lua_pushvalue(L, 3); - lua_call(L, 2, 0); - return 0; - } - - lua_pop(L, 1); - - //CONS_Printf("Adding custom field %s\n", luaL_checkstring(L, 2)); - - // Otherwise, set custom field - - lua_getfield(L, LUA_REGISTRYINDEX, LREG_EXTVARS); - I_Assert(lua_istable(L, -1)); - lua_pushlightuserdata(L, mo); - lua_rawget(L, -2); - if (lua_isnil(L, -1)) { - // This index doesn't have a table for extra values yet, let's make one. - lua_pop(L, 1); - CONS_Debug(DBG_LUA, M_GetText("'%s' has no field named '%s'; adding it as Lua data.\n"), "mobj_t", lua_tostring(L, 2)); - lua_newtable(L); - lua_pushlightuserdata(L, mo); - lua_pushvalue(L, -2); // ext value table - lua_rawset(L, -4); // LREG_EXTVARS table - } - lua_pushvalue(L, 2); // key - lua_pushvalue(L, 3); // value to store - lua_settable(L, -3); - lua_pop(L, 2); - - return 0; + // Try other skins + for (i = 0; i < numskins; i++) + { + if (fasticmp(skins[i].name, skin)) + { + mo->localskin = &skins[i]; + mo->skinlocal = false; + return 0; + } + } + } + else + { + mo->localskin = NULL; + mo->skinlocal = false; + } + } + break; + } + case mobj_blendmode: + { + INT32 blendmode = (INT32)luaL_checkinteger(L, 3); + if (blendmode < 0 || blendmode > AST_OVERLAY) + return luaL_error(L, "mobj.blendmode %d out of range (0 - %d).", blendmode, AST_OVERLAY); + mo->blendmode = blendmode; + break; + } + case mobj_mirrored: + mo->mirrored = luaL_checkboolean(L, 3); + break; + case mobj_islocal: + mo->islocal = luaL_checkboolean(L, 3); + break; + default: + lua_getfield(L, LUA_REGISTRYINDEX, LREG_EXTVARS); + I_Assert(lua_istable(L, -1)); + lua_pushlightuserdata(L, mo); + lua_rawget(L, -2); + if (lua_isnil(L, -1)) { + // This index doesn't have a table for extra values yet, let's make one. + lua_pop(L, 1); + CONS_Debug(DBG_LUA, M_GetText("'%s' has no field named '%s'; adding it as Lua data.\n"), "mobj_t", lua_tostring(L, 2)); + lua_newtable(L); + lua_pushlightuserdata(L, mo); + lua_pushvalue(L, -2); // ext value table + lua_rawset(L, -4); // LREG_EXTVARS table + } + lua_pushvalue(L, 2); // key + lua_pushvalue(L, 3); // value to store + lua_settable(L, -3); + lua_pop(L, 2); + break; + } + return 0; } #undef UNIMPLEMENTED @@ -982,14 +1015,14 @@ FUNCINLINE static ATTRINLINE int lib_nummapthings(lua_State *L) int LUA_MobjLib(lua_State *L) { + mobj_fields_ref = Lua_CreateFieldTable(L, mobj_opt); + luaL_newmetatable(L, META_MOBJ); lua_pushcfunction(L, mobj_get); lua_setfield(L, -2, "__index"); lua_pushcfunction(L, mobj_set); lua_setfield(L, -2, "__newindex"); - - udatalib_addfields(L, -1, mobj_fields); lua_pop(L,1); luaL_newmetatable(L, META_MAPTHING); diff --git a/src/lua_playerlib.c b/src/lua_playerlib.c index aa5fde833..e0af05485 100644 --- a/src/lua_playerlib.c +++ b/src/lua_playerlib.c @@ -26,365 +26,127 @@ #include "lua_hud.h" // hud_running errors #include "lua_hook.h" // hook_cmd_running -#include "lua_udatalib.h" +#define PLAYER_FIELDS(X) \ + X(valid) \ + X(name) \ + X(mo) \ + X(cmd) \ + X(playerstate) \ + X(viewz) \ + X(viewheight) \ + X(aiming) \ + X(health) \ + X(pity) \ + X(currentweapon) \ + X(ringweapons) \ + X(powers) \ + X(kartstuff) \ + X(frameangle) \ + X(pflags) \ + X(panim) \ + X(flashcount) \ + X(flashpal) \ + X(skincolor) \ + X(localskin) \ + X(score) \ + X(dashspeed) \ + X(dashtime) \ + X(kartspeed) \ + X(kartweight) \ + X(charflags) \ + X(lives) \ + X(continues) \ + X(xtralife) \ + X(gotcontinue) \ + X(speed) \ + X(jumping) \ + X(secondjump) \ + X(fly1) \ + X(scoreadd) \ + X(glidetime) \ + X(climbing) \ + X(deadtimer) \ + X(exiting) \ + X(homing) \ + X(skidtime) \ + X(cmomx) \ + X(cmomy) \ + X(rmomx) \ + X(rmomy) \ + X(numboxes) \ + X(totalring) \ + X(realtime) \ + X(laps) \ + X(ctfteam) \ + X(gotflag) \ + X(weapondelay) \ + X(tossdelay) \ + X(starpostx) \ + X(starposty) \ + X(starpostz) \ + X(starpostnum) \ + X(starposttime) \ + X(starpostangle) \ + X(angle_pos) \ + X(old_angle_pos) \ + X(axis1) \ + X(axis2) \ + X(bumpertime) \ + X(flyangle) \ + X(drilltimer) \ + X(linkcount) \ + X(linktimer) \ + X(anotherflyangle) \ + X(nightstime) \ + X(drillmeter) \ + X(drilldelay) \ + X(bonustime) \ + X(capsule) \ + X(mare) \ + X(marebegunat) \ + X(startedtime) \ + X(finishedtime) \ + X(finishedrings) \ + X(marescore) \ + X(lastmarescore) \ + X(lastmare) \ + X(maxlink) \ + X(texttimer) \ + X(textvar) \ + X(lastsidehit) \ + X(lastlinehit) \ + X(losstime) \ + X(timeshit) \ + X(onconveyor) \ + X(awayviewmobj) \ + X(awayviewtics) \ + X(awayviewaiming) \ + X(spectator) \ + X(bot) \ + X(jointime) \ + X(spectatorreentry) \ + X(grieftime) \ + X(griefstrikes) \ + X(splitscreenindex) \ + X(fovadd) \ + X(sliproll) \ + X(viewrollangle) \ + X(ping) -int player_name_getter(lua_State *L); -int player_name_noset(lua_State *L); -int player_mo_getter(lua_State *L); -int player_mo_setter(lua_State *L); -int player_cmd_noset(lua_State *L); -int player_aiming_setter(lua_State *L); -int player_powers_noset(lua_State *L); -int player_kartstuff_noset(lua_State *L); -int player_skincolor_setter(lua_State *L); -int player_axis_setter(lua_State *L); -int player_capsule_setter(lua_State *L); -int player_awayviewmobj_setter(lua_State *L); -int player_awayviewtics_setter(lua_State *L); -int player_bot_noset(lua_State *L); -int player_splitscreenindex_noset(lua_State *L); -int player_ping_getter(lua_State *L); -int player_ping_noset(lua_State *L); -int player_localskin_getter(lua_State *L); -int player_localskin_setter(lua_State *L); - -// Non synch safe! -int player_sliproll_getter(lua_State *L); -int player_sliproll_noset(lua_State *L); - -int player_viewrollangle_getter(lua_State *L); -int player_viewrollangle_noset(lua_State *L); - -#define FIELD(type, field_name, getter, setter) { #field_name, offsetof(type, field_name), getter, setter } -static const udata_field_t player_fields[] = { - // Player doesn't actually have field "name" so macro fails. Need to declare field manually. - { "name", 0, player_name_getter, player_name_noset }, - FIELD(player_t, mo, player_mo_getter, player_mo_setter), - FIELD(player_t, cmd, udatalib_getter_cmd, player_cmd_noset), - FIELD(player_t, playerstate, udatalib_getter_playerstate, udatalib_setter_playerstate), - FIELD(player_t, viewz, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(player_t, viewheight, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(player_t, aiming, udatalib_getter_angle, player_aiming_setter), - FIELD(player_t, health, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, pity, udatalib_getter_sint8, udatalib_setter_sint8), - FIELD(player_t, currentweapon, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, ringweapons, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, powers, udatalib_getter_powers, player_powers_noset), - FIELD(player_t, kartstuff, udatalib_getter_kartstuff, player_kartstuff_noset), - FIELD(player_t, frameangle, udatalib_getter_angle, udatalib_setter_angle), - FIELD(player_t, pflags, udatalib_getter_pflags, udatalib_setter_pflags), - FIELD(player_t, panim, udatalib_getter_panim, udatalib_setter_panim), - FIELD(player_t, flashcount, udatalib_getter_uint16, udatalib_setter_uint16), - FIELD(player_t, flashpal, udatalib_getter_uint16, udatalib_setter_uint16), - FIELD(player_t, skincolor, udatalib_getter_uint8, player_skincolor_setter), - FIELD(player_t, localskin, player_localskin_getter, player_localskin_setter), - FIELD(player_t, score, udatalib_getter_uint32, udatalib_setter_uint32), - FIELD(player_t, dashspeed, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(player_t, dashtime, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, kartspeed, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, kartweight, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, charflags, udatalib_getter_uint32, udatalib_setter_uint32), - FIELD(player_t, lives, udatalib_getter_sint8, udatalib_setter_sint8), - FIELD(player_t, continues, udatalib_getter_sint8, udatalib_setter_sint8), - FIELD(player_t, xtralife, udatalib_getter_sint8, udatalib_setter_sint8), - FIELD(player_t, gotcontinue, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, speed, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(player_t, jumping, udatalib_getter_boolean, udatalib_setter_boolean), - FIELD(player_t, secondjump, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, fly1, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, scoreadd, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, glidetime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, climbing, udatalib_getter_uint8, udatalib_setter_sint8), // For whatever reason, original setter casted to INT32... - FIELD(player_t, deadtimer, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, exiting, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, homing, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, skidtime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, cmomx, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(player_t, cmomy, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(player_t, rmomx, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(player_t, rmomy, udatalib_getter_fixed, udatalib_setter_fixed), - FIELD(player_t, numboxes, udatalib_getter_int16, udatalib_setter_int16), - FIELD(player_t, totalring, udatalib_getter_int16, udatalib_setter_int16), - FIELD(player_t, realtime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, laps, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, ctfteam, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, gotflag, udatalib_getter_uint16, udatalib_setter_uint16), - FIELD(player_t, weapondelay, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, tossdelay, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, starpostx, udatalib_getter_int16, udatalib_setter_int16), - FIELD(player_t, starposty, udatalib_getter_int16, udatalib_setter_int16), - FIELD(player_t, starpostz, udatalib_getter_int16, udatalib_setter_int16), - FIELD(player_t, starpostnum, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, starposttime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, starpostangle, udatalib_getter_angle, udatalib_setter_angle), - FIELD(player_t, angle_pos, udatalib_getter_angle, udatalib_setter_angle), - FIELD(player_t, old_angle_pos, udatalib_getter_angle, udatalib_setter_angle), - FIELD(player_t, axis1, udatalib_getter_mobj, player_axis_setter), - FIELD(player_t, axis2, udatalib_getter_mobj, player_axis_setter), - FIELD(player_t, bumpertime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, flyangle, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, drilltimer, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, linkcount, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, linktimer, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, anotherflyangle, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, nightstime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, drillmeter, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, drilldelay, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, bonustime, udatalib_getter_boolean, udatalib_setter_boolean), - FIELD(player_t, capsule, udatalib_getter_mobj, player_capsule_setter), - FIELD(player_t, mare, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, marebegunat, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, startedtime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, finishedtime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, finishedrings, udatalib_getter_int16, udatalib_setter_int16), - FIELD(player_t, marescore, udatalib_getter_uint32, udatalib_setter_uint32), - FIELD(player_t, lastmarescore, udatalib_getter_uint32, udatalib_setter_uint32), - FIELD(player_t, lastmare, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, maxlink, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, texttimer, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, textvar, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, lastsidehit, udatalib_getter_int16, udatalib_setter_int16), - FIELD(player_t, lastlinehit, udatalib_getter_int16, udatalib_setter_int16), - FIELD(player_t, losstime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, timeshit, udatalib_getter_uint8, udatalib_setter_uint8), // Haha, time shit, funni - FIELD(player_t, onconveyor, udatalib_getter_int32, udatalib_setter_int32), - FIELD(player_t, awayviewmobj, udatalib_getter_mobj, player_awayviewmobj_setter), - FIELD(player_t, awayviewtics, udatalib_getter_int32, player_awayviewtics_setter), - FIELD(player_t, awayviewaiming, udatalib_getter_angle, udatalib_setter_angle), - FIELD(player_t, spectator, udatalib_getter_boolean, udatalib_setter_boolean_nocheck), // ffs - FIELD(player_t, bot, udatalib_getter_uint8, player_bot_noset), - FIELD(player_t, jointime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, spectatorreentry, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, grieftime, udatalib_getter_tic, udatalib_setter_tic), - FIELD(player_t, griefstrikes, udatalib_getter_uint8, udatalib_setter_uint8), - FIELD(player_t, splitscreenindex, udatalib_getter_uint8, player_splitscreenindex_noset), - FIELD(player_t, fovadd, udatalib_getter_fixed, udatalib_setter_fixed), // Mmm yeah thats definitely synch safe - - // Same as player.name - { "sliproll", 0, player_sliproll_getter, player_sliproll_noset }, - { "viewrollangle", 0, player_viewrollangle_getter, player_viewrollangle_noset }, - { "ping", 0, player_ping_getter, player_ping_noset }, // Hmm originally setter doesn't exist so data is written as unreachable custom field... - { NULL, 0, NULL, NULL }, +enum player_e { +#define ENUMITEM(name) player_##name, + PLAYER_FIELDS(ENUMITEM) + NUMPLAYERFIELDS, +#undef ENUMITEM }; -#undef FIELD -// Implement udatalib simple getters -#define pushplayer(L, player) LUA_PushUserdata(L, player, META_PLAYER) -int udatalib_getter_player(lua_State *L) -UDATALIB_SIMPLE_GETTER(player_t*, pushplayer) -#undef pushplayer +static const char *player_opt[] = { +#define STRITEM(name) (#name), + PLAYER_FIELDS(STRITEM) + NULL, +}; -#define pushcmd(L, cmd) LUA_PushUserdata(L, &cmd, META_TICCMD) -int udatalib_getter_cmd(lua_State *L) -UDATALIB_SIMPLE_GETTER(ticcmd_t, pushcmd) -#undef pushcmd - -int udatalib_getter_playerstate(lua_State *L) -UDATALIB_SIMPLE_GETTER(playerstate_t, lua_pushinteger) - -int udatalib_setter_playerstate(lua_State *L) -UDATALIB_SIMPLE_SETTER(playerstate_t, luaL_checkinteger) - -#define pushpowers(L, powers) LUA_PushUserdata(L, &powers, META_POWERS) -int udatalib_getter_powers(lua_State *L) -UDATALIB_SIMPLE_GETTER(UINT16, pushpowers) -#undef pushpowers - -#define pushkartstuff(L, kartstuff) LUA_PushUserdata(L, &kartstuff, META_KARTSTUFF) -int udatalib_getter_kartstuff(lua_State *L) -UDATALIB_SIMPLE_GETTER(INT32, pushkartstuff) -#undef pushkartstuff - -int udatalib_getter_pflags(lua_State *L) -UDATALIB_SIMPLE_GETTER(pflags_t, lua_pushinteger) - -int udatalib_setter_pflags(lua_State *L) -UDATALIB_SIMPLE_SETTER(pflags_t, luaL_checkinteger) - -int udatalib_getter_panim(lua_State *L) -UDATALIB_SIMPLE_GETTER(panim_t, lua_pushinteger) - -int udatalib_setter_panim(lua_State *L) -UDATALIB_SIMPLE_SETTER(panim_t, luaL_checkinteger) -// Fields that cannot be set directly -#define NOSET(field) \ -int player_ ## field ## _noset(lua_State *L) \ -{ \ - return luaL_error(L, LUA_QL("player_t") " field " LUA_QS " should not be set directly.", #field); \ -} - -NOSET(name) -NOSET(cmd) -NOSET(powers) -NOSET(kartstuff) -NOSET(bot) -NOSET(splitscreenindex) -NOSET(ping) -NOSET(sliproll) -NOSET(viewrollangle) - -#undef NOSET - -// Rest of getters/setters with arbitary logic - - -#define GETPLAYER() (player_t*)lua_touserdata(L, 1) - -int player_name_getter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - lua_pushstring(L, player_names[plr-players]); - - return 1; -} - -int player_mo_getter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - if (plr->spectator) - lua_pushnil(L); - else - LUA_PushUserdata(L, plr->mo, META_MOBJ); - - return 1; -} - -int player_mo_setter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - mobj_t *newmo = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ)); - plr->mo->player = NULL; // remove player pointer from old mobj - (newmo->player = plr)->mo = newmo; // set player pointer for new mobj, and set new mobj as the player's mobj - - return 0; -} - -int player_aiming_setter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - plr->aiming = luaL_checkangle(L, 2); - for (UINT8 i = 0; i <= splitscreen; i++) - { - if (plr == P_GetLocalPlayerForNum(i)) - { - localaiming[i] = plr->aiming; - break; - } - } - - return 0; -} - -int player_skincolor_setter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - UINT8 newcolor = (UINT8)luaL_checkinteger(L,2); - if (newcolor >= MAXSKINCOLORS) - return luaL_error(L, "player.skincolor %d out of range (0 - %d).", newcolor, MAXSKINCOLORS-1); - plr->skincolor = newcolor; - - return 0; -} - -int player_localskin_getter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - if (plr->localskin) - lua_pushstring(L, K_GetPlayerSkin(plr)->name); - else - lua_pushnil(L); - - return 1; -} - -int player_localskin_setter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - SetLocalPlayerSkin(plr - players, luaL_optstring(L, 2, "none"), NULL); - - return 0; -} - -int player_axis_setter(lua_State *L) -{ - mobj_t **axis; - - UDATALIB_GETFIELD(mobj_t*, axis); - - P_SetTarget(axis, *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ))); - - return 0; -} - -int player_capsule_setter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - mobj_t *mo = NULL; - if (!lua_isnil(L, 2)) - mo = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ)); - P_SetTarget(&plr->capsule, mo); - - return 0; -} - -// Probably can do same thing as with axis1 and axis2 -int player_awayviewmobj_setter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - mobj_t *mo = NULL; - if (!lua_isnil(L, 2)) - mo = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ)); - P_SetTarget(&plr->awayviewmobj, mo); - - return 0; -} - -int player_awayviewtics_setter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - plr->awayviewtics = (INT32)luaL_checkinteger(L, 2); - if (plr->awayviewtics && !plr->awayviewmobj) // awayviewtics must ALWAYS have an awayviewmobj set!! - P_SetTarget(&plr->awayviewmobj, plr->mo); // but since the script might set awayviewmobj immediately AFTER setting awayviewtics, use player mobj as filler for now. - - return 0; -} - -int player_ping_getter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - lua_pushinteger(L, playerpingtable[( plr - players )]); - - return 1; -} - -int player_sliproll_getter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - lua_pushangle(L, R_PlayerSliptideAngle(plr)); - - return 1; -} - -int player_viewrollangle_getter(lua_State *L) -{ - player_t *plr = GETPLAYER(); - - lua_pushangle(L, R_ViewRollAngle(plr)); - - return 1; -} +static int player_fields_ref = LUA_NOREF; static int lib_iteratePlayers(lua_State *L) { @@ -514,57 +276,380 @@ FUNCINLINE static ATTRINLINE int lib_lenDisplayplayers(lua_State *L) static int player_get(lua_State *L) { player_t *plr = *((player_t **)luaL_checkudata(L, 1, META_PLAYER)); - const char *field = luaL_checkstring(L, 2); // Still gotta have 2 strcmp's + enum player_e field = Lua_optoption(L, 2, -1, player_fields_ref); if (!plr) { - if (fastcmp(field,"valid")) { + if (field == player_valid) { lua_pushboolean(L, false); return 1; } return LUA_ErrInvalid(L, "player_t"); - } else if (fastcmp(field,"valid")) { + } else if (field == player_valid) { lua_pushboolean(L, true); return 1; } - lua_getmetatable(L, 1); - - lua_pushvalue(L, 2); // Push field name - lua_rawget(L, -2); // Get getter/setter table from metatable - - // If field exists, run getter for it - if (!lua_isnil(L, -1)) { - //CONS_Printf("Running getter for field %s\n", field); - lua_rawgeti(L, -1, UDATALIB_GETTER); - lua_pushlightuserdata(L, plr); - lua_call(L, 1, 1); - //CONS_Printf("Getter returned %s\n", lua_typename(L, lua_type(L, -1))); - return 1; - } - - lua_pop(L, 1); - - lua_getfield(L, LUA_REGISTRYINDEX, LREG_EXTVARS); - I_Assert(lua_istable(L, -1)); - lua_pushlightuserdata(L, plr); - lua_rawget(L, -2); - if (!lua_istable(L, -1)) { // no extra values table - CONS_Debug(DBG_LUA, M_GetText("'%s' has no extvars table or field named '%s'; returning nil.\n"), "player_t", field); - return 0; - } - lua_getfield(L, -1, field); - if (lua_isnil(L, -1)) // no value for this field + switch (field) { - CONS_Debug(DBG_LUA, M_GetText("'%s' has no field named '%s'; returning nil.\n"), "player_t", field); + case player_valid: + lua_pushboolean(L, true); + break; + case player_name: + lua_pushstring(L, player_names[plr-players]); + break; + case player_mo: + { + if (plr->spectator) + lua_pushnil(L); + else + LUA_PushUserdata(L, plr->mo, META_MOBJ); + } + break; + case player_cmd: + LUA_PushUserdata(L, &plr->cmd, META_TICCMD); + break; + case player_playerstate: + lua_pushinteger(L, plr->playerstate); + break; + case player_viewz: + lua_pushfixed(L, plr->viewz); + break; + case player_viewheight: + lua_pushfixed(L, plr->viewheight); + /* break; + case player_deltaviewheight: + lua_pushfixed(L, plr->deltaviewheight); + break; + case player_bob: + lua_pushfixed(L, plr->bob);*/ + break; + case player_aiming: + lua_pushangle(L, plr->aiming); + break; + case player_health: + lua_pushinteger(L, plr->health); + break; + case player_pity: + lua_pushinteger(L, plr->pity); + break; + case player_currentweapon: + lua_pushinteger(L, plr->currentweapon); + break; + case player_ringweapons: + lua_pushinteger(L, plr->ringweapons); + break; + case player_powers: + LUA_PushUserdata(L, plr->powers, META_POWERS); + break; + case player_kartstuff: + LUA_PushUserdata(L, plr->kartstuff, META_KARTSTUFF); + break; + case player_frameangle: + lua_pushangle(L, plr->frameangle); + break; + case player_pflags: + lua_pushinteger(L, plr->pflags); + break; + case player_panim: + lua_pushinteger(L, plr->panim); + break; + case player_flashcount: + lua_pushinteger(L, plr->flashcount); + break; + case player_flashpal: + lua_pushinteger(L, plr->flashpal); + break; + case player_skincolor: + lua_pushinteger(L, plr->skincolor); + break; + case player_score: + lua_pushinteger(L, plr->score); + break; + case player_dashspeed: + lua_pushfixed(L, plr->dashspeed); + break; + case player_dashtime: + lua_pushinteger(L, plr->dashtime); + // SRB2kart + break; + case player_kartspeed: + lua_pushinteger(L, plr->kartspeed); + break; + case player_kartweight: + lua_pushinteger(L, plr->kartweight); + // + break; + case player_charflags: + lua_pushinteger(L, plr->charflags); + break; + case player_lives: + lua_pushinteger(L, plr->lives); + break; + case player_continues: + lua_pushinteger(L, plr->continues); + break; + case player_xtralife: + lua_pushinteger(L, plr->xtralife); + break; + case player_gotcontinue: + lua_pushinteger(L, plr->gotcontinue); + break; + case player_speed: + lua_pushfixed(L, plr->speed); + break; + case player_jumping: + lua_pushboolean(L, plr->jumping); + break; + case player_secondjump: + lua_pushinteger(L, plr->secondjump); + break; + case player_fly1: + lua_pushinteger(L, plr->fly1); + break; + case player_scoreadd: + lua_pushinteger(L, plr->scoreadd); + break; + case player_glidetime: + lua_pushinteger(L, plr->glidetime); + break; + case player_climbing: + lua_pushinteger(L, plr->climbing); + break; + case player_deadtimer: + lua_pushinteger(L, plr->deadtimer); + break; + case player_exiting: + lua_pushinteger(L, plr->exiting); + break; + case player_homing: + lua_pushinteger(L, plr->homing); + break; + case player_skidtime: + lua_pushinteger(L, plr->skidtime); + break; + case player_cmomx: + lua_pushfixed(L, plr->cmomx); + break; + case player_cmomy: + lua_pushfixed(L, plr->cmomy); + break; + case player_rmomx: + lua_pushfixed(L, plr->rmomx); + break; + case player_rmomy: + lua_pushfixed(L, plr->rmomy); + break; + case player_numboxes: + lua_pushinteger(L, plr->numboxes); + break; + case player_totalring: + lua_pushinteger(L, plr->totalring); + break; + case player_realtime: + lua_pushinteger(L, plr->realtime); + break; + case player_laps: + lua_pushinteger(L, plr->laps); + break; + case player_ctfteam: + lua_pushinteger(L, plr->ctfteam); + break; + case player_gotflag: + lua_pushinteger(L, plr->gotflag); + break; + case player_weapondelay: + lua_pushinteger(L, plr->weapondelay); + break; + case player_tossdelay: + lua_pushinteger(L, plr->tossdelay); + break; + case player_starpostx: + lua_pushinteger(L, plr->starpostx); + break; + case player_starposty: + lua_pushinteger(L, plr->starposty); + break; + case player_starpostz: + lua_pushinteger(L, plr->starpostz); + break; + case player_starpostnum: + lua_pushinteger(L, plr->starpostnum); + break; + case player_starposttime: + lua_pushinteger(L, plr->starposttime); + break; + case player_starpostangle: + lua_pushangle(L, plr->starpostangle); + break; + case player_angle_pos: + lua_pushangle(L, plr->angle_pos); + break; + case player_old_angle_pos: + lua_pushangle(L, plr->old_angle_pos); + break; + case player_axis1: + LUA_PushUserdata(L, plr->axis1, META_MOBJ); + break; + case player_axis2: + LUA_PushUserdata(L, plr->axis2, META_MOBJ); + break; + case player_bumpertime: + lua_pushinteger(L, plr->bumpertime); + break; + case player_flyangle: + lua_pushinteger(L, plr->flyangle); + break; + case player_drilltimer: + lua_pushinteger(L, plr->drilltimer); + break; + case player_linkcount: + lua_pushinteger(L, plr->linkcount); + break; + case player_linktimer: + lua_pushinteger(L, plr->linktimer); + break; + case player_anotherflyangle: + lua_pushinteger(L, plr->anotherflyangle); + break; + case player_nightstime: + lua_pushinteger(L, plr->nightstime); + break; + case player_drillmeter: + lua_pushinteger(L, plr->drillmeter); + break; + case player_drilldelay: + lua_pushinteger(L, plr->drilldelay); + break; + case player_bonustime: + lua_pushboolean(L, plr->bonustime); + break; + case player_capsule: + LUA_PushUserdata(L, plr->capsule, META_MOBJ); + break; + case player_mare: + lua_pushinteger(L, plr->mare); + break; + case player_marebegunat: + lua_pushinteger(L, plr->marebegunat); + break; + case player_startedtime: + lua_pushinteger(L, plr->startedtime); + break; + case player_finishedtime: + lua_pushinteger(L, plr->finishedtime); + break; + case player_finishedrings: + lua_pushinteger(L, plr->finishedrings); + break; + case player_marescore: + lua_pushinteger(L, plr->marescore); + break; + case player_lastmarescore: + lua_pushinteger(L, plr->lastmarescore); + break; + case player_lastmare: + lua_pushinteger(L, plr->lastmare); + break; + case player_maxlink: + lua_pushinteger(L, plr->maxlink); + break; + case player_texttimer: + lua_pushinteger(L, plr->texttimer); + break; + case player_textvar: + lua_pushinteger(L, plr->textvar); + break; + case player_lastsidehit: + lua_pushinteger(L, plr->lastsidehit); + break; + case player_lastlinehit: + lua_pushinteger(L, plr->lastlinehit); + break; + case player_losstime: + lua_pushinteger(L, plr->losstime); + break; + case player_timeshit: + lua_pushinteger(L, plr->timeshit); + break; + case player_onconveyor: + lua_pushinteger(L, plr->onconveyor); + break; + case player_awayviewmobj: + LUA_PushUserdata(L, plr->awayviewmobj, META_MOBJ); + break; + case player_awayviewtics: + lua_pushinteger(L, plr->awayviewtics); + break; + case player_awayviewaiming: + lua_pushangle(L, plr->awayviewaiming); + break; + case player_spectator: + lua_pushboolean(L, plr->spectator); + break; + case player_bot: + lua_pushinteger(L, plr->bot); + break; + case player_jointime: + lua_pushinteger(L, plr->jointime); + break; + case player_spectatorreentry: + lua_pushinteger(L, plr->spectatorreentry); + break; + case player_grieftime: + lua_pushinteger(L, plr->grieftime); + break; + case player_griefstrikes: + lua_pushinteger(L, plr->griefstrikes); + break; + case player_splitscreenindex: + lua_pushinteger(L, plr->splitscreenindex); + break; +#ifdef HWRENDER + case player_fovadd: + lua_pushfixed(L, plr->fovadd); + break; +#endif + case player_ping: + lua_pushinteger(L, playerpingtable[( plr - players )]); + break; + // Saturn + case player_localskin: + if (plr->localskin) + lua_pushstring(L, K_GetPlayerSkin(plr)->name); + else + lua_pushnil(L); + break; + case player_sliproll: + lua_pushangle(L, R_PlayerSliptideAngle(plr)); + break; + case player_viewrollangle: + lua_pushangle(L, R_ViewRollAngle(plr)); + break; + default: + lua_getfield(L, LUA_REGISTRYINDEX, LREG_EXTVARS); + I_Assert(lua_istable(L, -1)); + lua_pushlightuserdata(L, plr); + lua_rawget(L, -2); + if (!lua_istable(L, -1)) { // no extra values table + CONS_Debug(DBG_LUA, M_GetText("'%s' has no extvars table or field named '%s'; returning nil.\n"), "player_t", lua_tostring(L, 2)); + return 0; + } + lua_pushvalue(L, 2); // field name + lua_gettable(L, -2); + if (lua_isnil(L, -1)) // no value for this field + CONS_Debug(DBG_LUA, M_GetText("'%s' has no field named '%s'; returning nil.\n"), "player_t", lua_tostring(L, 2)); + break; } return 1; } +#define NOSET luaL_error(L, LUA_QL("player_t") " field " LUA_QS " should not be set directly.", lua_tostring(L, 2)) static int player_set(lua_State *L) { player_t *plr = *((player_t **)luaL_checkudata(L, 1, META_PLAYER)); - const char *field = luaL_checkstring(L, 2); + enum player_e field = Lua_optoption(L, 2, player_cmd, player_fields_ref); + if (!plr) return LUA_ErrInvalid(L, "player_t"); @@ -574,39 +659,379 @@ static int player_set(lua_State *L) if (hook_cmd_running) return luaL_error(L, "Do not alter player_t in BuildCMD code!"); - lua_getmetatable(L, 1); // Push metatable - - lua_pushvalue(L, 2); // Push field name - lua_rawget(L, -2); // Get getter/setter table from metatable - - // If field exists, run setter for it - if (!lua_isnil(L, -1)) { - //CONS_Printf("Running setter for field %s\n", luaL_checkstring(L, 2)); - lua_rawgeti(L, -1, UDATALIB_SETTER); - lua_pushlightuserdata(L, plr); - lua_pushvalue(L, 3); - lua_call(L, 2, 0); - return 0; - } - - lua_pop(L, 1); - - lua_getfield(L, LUA_REGISTRYINDEX, LREG_EXTVARS); - I_Assert(lua_istable(L, -1)); - lua_pushlightuserdata(L, plr); - lua_rawget(L, -2); - if (lua_isnil(L, -1)) { - // This index doesn't have a table for extra values yet, let's make one. - lua_pop(L, 1); - CONS_Debug(DBG_LUA, M_GetText("'%s' has no field named '%s'; adding it as Lua data.\n"), "player_t", field); - lua_newtable(L); - lua_pushlightuserdata(L, plr); - lua_pushvalue(L, -2); // ext value table - lua_rawset(L, -4); // LREG_EXTVARS table - } - lua_pushvalue(L, 3); // value to store - lua_setfield(L, -2, field); - lua_pop(L, 2); + switch (field) + { + case player_name: + case player_valid: + case player_ping: + //return NOSET; + return 0; // In vanilla those are not handled and are added into player fields table, but they aren't accessible anyway so we can just ignore them + break; + case player_mo: + { + mobj_t *newmo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); + plr->mo->player = NULL; // remove player pointer from old mobj + (newmo->player = plr)->mo = newmo; // set player pointer for new mobj, and set new mobj as the player's mobj + } + break; + case player_cmd: + return NOSET; + break; + case player_playerstate: + plr->playerstate = luaL_checkinteger(L, 3); + break; + case player_viewz: + plr->viewz = luaL_checkfixed(L, 3); + break; + case player_viewheight: + plr->viewheight = luaL_checkfixed(L, 3); + /* break; + case player_deltaviewheight: + plr->deltaviewheight = luaL_checkfixed(L, 3); + break; + case player_bob: + plr->bob = luaL_checkfixed(L, 3);*/ + break; + case player_aiming: { + plr->aiming = luaL_checkangle(L, 3); + if (plr == &players[consoleplayer]) + localaiming[0] = plr->aiming; + else if (plr == &players[displayplayers[1]]) + localaiming[1] = plr->aiming; + else if (plr == &players[displayplayers[2]]) + localaiming[2] = plr->aiming; + else if (plr == &players[displayplayers[3]]) + localaiming[3] = plr->aiming; + } + break; + case player_health: + plr->health = (INT32)luaL_checkinteger(L, 3); + break; + case player_pity: + plr->pity = (SINT8)luaL_checkinteger(L, 3); + break; + case player_currentweapon: + plr->currentweapon = (INT32)luaL_checkinteger(L, 3); + break; + case player_ringweapons: + plr->ringweapons = (INT32)luaL_checkinteger(L, 3); + break; + case player_powers: + return NOSET; + break; + case player_pflags: + plr->pflags = luaL_checkinteger(L, 3); + break; + case player_panim: + plr->panim = luaL_checkinteger(L, 3); + break; + case player_flashcount: + plr->flashcount = (UINT16)luaL_checkinteger(L, 3); + break; + case player_flashpal: + plr->flashpal = (UINT16)luaL_checkinteger(L, 3); + break; + case player_skincolor: + { + UINT8 newcolor = (UINT8)luaL_checkinteger(L,3); + if (newcolor >= MAXSKINCOLORS) + return luaL_error(L, "player.skincolor %d out of range (0 - %d).", newcolor, MAXSKINCOLORS-1); + plr->skincolor = newcolor; + } + break; + case player_score: + plr->score = (UINT32)luaL_checkinteger(L, 3); + break; + case player_dashspeed: + plr->dashspeed = luaL_checkfixed(L, 3); + break; + case player_dashtime: + plr->dashtime = (INT32)luaL_checkinteger(L, 3); + // SRB2kart + break; + case player_kartstuff: + return NOSET; + break; + case player_frameangle: + plr->frameangle = luaL_checkangle(L, 3); + break; + case player_kartspeed: + plr->kartspeed = (UINT8)luaL_checkinteger(L, 3); + break; + case player_kartweight: + plr->kartweight = (UINT8)luaL_checkinteger(L, 3); + // + break; + case player_charflags: + plr->charflags = (UINT32)luaL_checkinteger(L, 3); + break; + case player_lives: + plr->lives = (SINT8)luaL_checkinteger(L, 3); + break; + case player_continues: + plr->continues = (SINT8)luaL_checkinteger(L, 3); + break; + case player_xtralife: + plr->xtralife = (SINT8)luaL_checkinteger(L, 3); + break; + case player_gotcontinue: + plr->gotcontinue = (UINT8)luaL_checkinteger(L, 3); + break; + case player_speed: + plr->speed = luaL_checkfixed(L, 3); + break; + case player_jumping: + plr->jumping = luaL_checkboolean(L, 3); + break; + case player_secondjump: + plr->secondjump = (UINT8)luaL_checkinteger(L, 3); + break; + case player_fly1: + plr->fly1 = (UINT8)luaL_checkinteger(L, 3); + break; + case player_scoreadd: + plr->scoreadd = (UINT8)luaL_checkinteger(L, 3); + break; + case player_glidetime: + plr->glidetime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_climbing: + plr->climbing = (INT32)luaL_checkinteger(L, 3); + break; + case player_deadtimer: + plr->deadtimer = (INT32)luaL_checkinteger(L, 3); + break; + case player_exiting: + plr->exiting = (tic_t)luaL_checkinteger(L, 3); + break; + case player_homing: + plr->homing = (UINT8)luaL_checkinteger(L, 3); + break; + case player_skidtime: + plr->skidtime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_cmomx: + plr->cmomx = luaL_checkfixed(L, 3); + break; + case player_cmomy: + plr->cmomy = luaL_checkfixed(L, 3); + break; + case player_rmomx: + plr->rmomx = luaL_checkfixed(L, 3); + break; + case player_rmomy: + plr->rmomy = luaL_checkfixed(L, 3); + break; + case player_numboxes: + plr->numboxes = (INT16)luaL_checkinteger(L, 3); + break; + case player_totalring: + plr->totalring = (INT16)luaL_checkinteger(L, 3); + break; + case player_realtime: + plr->realtime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_laps: + plr->laps = (UINT8)luaL_checkinteger(L, 3); + break; + case player_ctfteam: + plr->ctfteam = (INT32)luaL_checkinteger(L, 3); + break; + case player_gotflag: + plr->gotflag = (UINT16)luaL_checkinteger(L, 3); + break; + case player_weapondelay: + plr->weapondelay = (INT32)luaL_checkinteger(L, 3); + break; + case player_tossdelay: + plr->tossdelay = (INT32)luaL_checkinteger(L, 3); + break; + case player_starpostx: + plr->starpostx = (INT16)luaL_checkinteger(L, 3); + break; + case player_starposty: + plr->starposty = (INT16)luaL_checkinteger(L, 3); + break; + case player_starpostz: + plr->starpostz = (INT16)luaL_checkinteger(L, 3); + break; + case player_starpostnum: + plr->starpostnum = (INT32)luaL_checkinteger(L, 3); + break; + case player_starposttime: + plr->starposttime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_starpostangle: + plr->starpostangle = luaL_checkangle(L, 3); + break; + case player_angle_pos: + plr->angle_pos = luaL_checkangle(L, 3); + break; + case player_old_angle_pos: + plr->old_angle_pos = luaL_checkangle(L, 3); + break; + case player_axis1: + P_SetTarget(&plr->axis1, *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ))); + break; + case player_axis2: + P_SetTarget(&plr->axis2, *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ))); + break; + case player_bumpertime: + plr->bumpertime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_flyangle: + plr->flyangle = (INT32)luaL_checkinteger(L, 3); + break; + case player_drilltimer: + plr->drilltimer = (tic_t)luaL_checkinteger(L, 3); + break; + case player_linkcount: + plr->linkcount = (INT32)luaL_checkinteger(L, 3); + break; + case player_linktimer: + plr->linktimer = (tic_t)luaL_checkinteger(L, 3); + break; + case player_anotherflyangle: + plr->anotherflyangle = (INT32)luaL_checkinteger(L, 3); + break; + case player_nightstime: + plr->nightstime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_drillmeter: + plr->drillmeter = (INT32)luaL_checkinteger(L, 3); + break; + case player_drilldelay: + plr->drilldelay = (UINT8)luaL_checkinteger(L, 3); + break; + case player_bonustime: + plr->bonustime = luaL_checkboolean(L, 3); + break; + case player_capsule: + { + mobj_t *mo = NULL; + if (!lua_isnil(L, 3)) + mo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); + P_SetTarget(&plr->capsule, mo); + } + break; + case player_mare: + plr->mare = (UINT8)luaL_checkinteger(L, 3); + break; + case player_marebegunat: + plr->marebegunat = (tic_t)luaL_checkinteger(L, 3); + break; + case player_startedtime: + plr->startedtime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_finishedtime: + plr->finishedtime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_finishedrings: + plr->finishedrings = (INT16)luaL_checkinteger(L, 3); + break; + case player_marescore: + plr->marescore = (UINT32)luaL_checkinteger(L, 3); + break; + case player_lastmarescore: + plr->lastmarescore = (UINT32)luaL_checkinteger(L, 3); + break; + case player_lastmare: + plr->lastmare = (UINT8)luaL_checkinteger(L, 3); + break; + case player_maxlink: + plr->maxlink = (INT32)luaL_checkinteger(L, 3); + break; + case player_texttimer: + plr->texttimer = (UINT8)luaL_checkinteger(L, 3); + break; + case player_textvar: + plr->textvar = (UINT8)luaL_checkinteger(L, 3); + break; + case player_lastsidehit: + plr->lastsidehit = (INT16)luaL_checkinteger(L, 3); + break; + case player_lastlinehit: + plr->lastlinehit = (INT16)luaL_checkinteger(L, 3); + break; + case player_losstime: + plr->losstime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_timeshit: + plr->timeshit = (UINT8)luaL_checkinteger(L, 3); + break; + case player_onconveyor: + plr->onconveyor = (INT32)luaL_checkinteger(L, 3); + break; + case player_awayviewmobj: + { + mobj_t *mo = NULL; + if (!lua_isnil(L, 3)) + mo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); + P_SetTarget(&plr->awayviewmobj, mo); + } + break; + case player_awayviewtics: + { + plr->awayviewtics = (INT32)luaL_checkinteger(L, 3); + if (plr->awayviewtics && !plr->awayviewmobj) // awayviewtics must ALWAYS have an awayviewmobj set!! + P_SetTarget(&plr->awayviewmobj, plr->mo); // but since the script might set awayviewmobj immediately AFTER setting awayviewtics, use player mobj as filler for now. + } + break; + case player_awayviewaiming: + plr->awayviewaiming = luaL_checkangle(L, 3); + break; + case player_spectator: + plr->spectator = lua_toboolean(L, 3); + break; + case player_bot: + return NOSET; + break; + case player_jointime: + plr->jointime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_spectatorreentry: + plr->spectatorreentry = (tic_t)luaL_checkinteger(L, 3); + break; + case player_grieftime: + plr->grieftime = (tic_t)luaL_checkinteger(L, 3); + break; + case player_griefstrikes: + plr->griefstrikes = (UINT8)luaL_checkinteger(L, 3); + break; + case player_splitscreenindex: + return NOSET; + break; +#ifdef HWRENDER + case player_fovadd: + plr->fovadd = luaL_checkfixed(L, 3); + break; +#endif + // Saturn + case player_localskin: + SetLocalPlayerSkin(plr - players, luaL_optstring(L, 2, "none"), NULL); + break; + case player_sliproll: + case player_viewrollangle: + return NOSET; + break; + default: + lua_getfield(L, LUA_REGISTRYINDEX, LREG_EXTVARS); + I_Assert(lua_istable(L, -1)); + lua_pushlightuserdata(L, plr); + lua_rawget(L, -2); + if (lua_isnil(L, -1)) { + // This index doesn't have a table for extra values yet, let's make one. + lua_pop(L, 1); + CONS_Debug(DBG_LUA, M_GetText("'%s' has no field named '%s'; adding it as Lua data.\n"), "player_t", lua_tostring(L, 2)); + lua_newtable(L); + lua_pushlightuserdata(L, plr); + lua_pushvalue(L, -2); // ext value table + lua_rawset(L, -4); // LREG_EXTVARS table + } + lua_pushvalue(L, 3); // value to store + lua_setfield(L, -2, lua_tostring(L, 2)); + lua_pop(L, 2); + } return 0; } @@ -798,6 +1223,8 @@ static int ticcmd_set(lua_State *L) int LUA_PlayerLib(lua_State *L) { + player_fields_ref = Lua_CreateFieldTable(L, player_opt); + luaL_newmetatable(L, META_PLAYER); lua_pushcfunction(L, player_get); lua_setfield(L, -2, "__index"); @@ -807,8 +1234,6 @@ int LUA_PlayerLib(lua_State *L) lua_pushcfunction(L, player_num); lua_setfield(L, -2, "__len"); - - udatalib_addfields(L, -1, player_fields); lua_pop(L,1); luaL_newmetatable(L, META_POWERS); diff --git a/src/lua_udatalib.c b/src/lua_udatalib.c deleted file mode 100644 index 962fb0638..000000000 --- a/src/lua_udatalib.c +++ /dev/null @@ -1,137 +0,0 @@ -// SONIC ROBO BLAST 2 KART SATURN -//----------------------------------------------------------------------------- -// Copyright (C) 2025 by Indev. -// -// This program is free software distributed under the -// terms of the GNU General Public License, version 2. -// See the 'LICENSE' file for more details. -//----------------------------------------------------------------------------- -/// \file lua_udatalib.c -/// \brief Implementation of lua userdata object metatables based on getter/setter functions - -#include "doomtype.h" -#include "m_fixed.h" -#include "lua_udatalib.h" - -// Getters -int udatalib_getter_fixed(lua_State *L) -UDATALIB_SIMPLE_GETTER(fixed_t, lua_pushinteger) - -int udatalib_getter_angle(lua_State *L) -UDATALIB_SIMPLE_GETTER(angle_t, lua_pushangle) - -int udatalib_getter_uint8(lua_State *L) -UDATALIB_SIMPLE_GETTER(UINT8, lua_pushinteger) - -int udatalib_getter_sint8(lua_State *L) -UDATALIB_SIMPLE_GETTER(SINT8, lua_pushinteger) - -int udatalib_getter_uint16(lua_State *L) -UDATALIB_SIMPLE_GETTER(UINT16, lua_pushinteger) - -int udatalib_getter_int16(lua_State *L) -UDATALIB_SIMPLE_GETTER(INT16, lua_pushinteger) - -int udatalib_getter_uint32(lua_State *L) -UDATALIB_SIMPLE_GETTER(UINT32, lua_pushinteger) - -int udatalib_getter_int32(lua_State *L) -UDATALIB_SIMPLE_GETTER(INT32, lua_pushinteger) - -int udatalib_getter_uint64(lua_State *L) -UDATALIB_SIMPLE_GETTER(UINT64, lua_pushinteger) - -int udatalib_getter_int64(lua_State *L) -UDATALIB_SIMPLE_GETTER(INT64, lua_pushinteger) - -int udatalib_getter_string(lua_State *L) -UDATALIB_SIMPLE_GETTER(const char*, lua_pushstring) - -int udatalib_getter_boolean(lua_State *L) -UDATALIB_SIMPLE_GETTER(boolean, lua_pushboolean) - -int udatalib_getter_spritenum(lua_State *L) -UDATALIB_SIMPLE_GETTER(spritenum_t, lua_pushinteger) - -int udatalib_getter_tic(lua_State *L) -UDATALIB_SIMPLE_GETTER(tic_t, lua_pushinteger) - -// Setters -int udatalib_setter_fixed(lua_State *L) -UDATALIB_SIMPLE_SETTER(fixed_t, luaL_checkfixed) - -int udatalib_setter_angle(lua_State *L) -UDATALIB_SIMPLE_SETTER(angle_t, luaL_checkangle) - -int udatalib_setter_uint8(lua_State *L) -UDATALIB_SIMPLE_SETTER(UINT8, (UINT8)luaL_checkinteger) - -int udatalib_setter_sint8(lua_State *L) -UDATALIB_SIMPLE_SETTER(SINT8, luaL_checkinteger) - -int udatalib_setter_uint16(lua_State *L) -UDATALIB_SIMPLE_SETTER(UINT16, (UINT16)luaL_checkinteger) - -int udatalib_setter_int16(lua_State *L) -UDATALIB_SIMPLE_SETTER(INT16, luaL_checkinteger) - -int udatalib_setter_uint32(lua_State *L) -UDATALIB_SIMPLE_SETTER(UINT32, (UINT32)luaL_checkinteger) - -int udatalib_setter_int32(lua_State *L) -UDATALIB_SIMPLE_SETTER(INT32, luaL_checkinteger) - -int udatalib_setter_uint64(lua_State *L) -UDATALIB_SIMPLE_SETTER(UINT64, (UINT64)luaL_checkinteger) - -int udatalib_setter_int64(lua_State *L) -UDATALIB_SIMPLE_SETTER(INT64, luaL_checkinteger) - -int udatalib_setter_string(lua_State *L) -UDATALIB_SIMPLE_SETTER(const char*, luaL_checkstring) - -int udatalib_setter_boolean(lua_State *L) -UDATALIB_SIMPLE_SETTER(boolean, luaL_checkboolean) - -// ffs -int udatalib_setter_boolean_nocheck(lua_State *L) -UDATALIB_SIMPLE_SETTER(boolean, lua_toboolean) - -int udatalib_setter_spritenum(lua_State *L) -UDATALIB_SIMPLE_SETTER(spritenum_t, luaL_checkinteger) - -int udatalib_setter_tic(lua_State *L) -UDATALIB_SIMPLE_SETTER(tic_t, (tic_t)luaL_checkinteger) - - -void udatalib_addfield(lua_State *L, int mt, udata_field_t field) -{ - int idx = abs_index(L, mt); - - lua_createtable(L, 2, 0); // Push table - - lua_pushinteger(L, field.offset); // Push offset - lua_pushcclosure(L, field.getter, 1); // Pop offset, push closure - - lua_rawseti(L, -2, UDATALIB_GETTER); // Pop closure, add to table - - lua_pushinteger(L, field.offset); // Push offset - lua_pushcclosure(L, field.setter, 1); // Pop offset, push closure - - lua_rawseti(L, -2, UDATALIB_SETTER); // Pop closure, add to table - - lua_pushstring(L, field.name); // Push field name - lua_pushvalue(L, -2); // Copy table - lua_rawset(L, idx); // Pop field name and table, add to metatable - - lua_pop(L, 1); // Pop field table -} - -void udatalib_addfields(lua_State *L, int mt, const udata_field_t fields[]) -{ - for (unsigned i = 0; fields[i].name != NULL; ++i) - { - udatalib_addfield(L, mt, fields[i]); - //CONS_Printf("Add field name=%s, offset=%d, getter=%p, setter=%p\n", fields[i].name, fields[i].offset, fields[i].getter, fields[i].setter); - } -} diff --git a/src/lua_udatalib.h b/src/lua_udatalib.h deleted file mode 100644 index ad23bf898..000000000 --- a/src/lua_udatalib.h +++ /dev/null @@ -1,114 +0,0 @@ -// SONIC ROBO BLAST 2 KART SATURN -//----------------------------------------------------------------------------- -// Copyright (C) 2025 by Indev. -// -// This program is free software distributed under the -// terms of the GNU General Public License, version 2. -// See the 'LICENSE' file for more details. -//----------------------------------------------------------------------------- -/// \file lua_udatalib.h -/// \brief Implementation of lua userdata object metatables based on getter/setter functions - -#ifndef __LUA_UDATALIB_H__ -#define __LUA_UDATALIB_H__ - -#include "doomdef.h" -#include "lua_script.h" -#include "lua_libs.h" -#include "fastcmp.h" - -// Indices in getter/setter tables for fields -#define UDATALIB_GETTER 1 -#define UDATALIB_SETTER 2 - -typedef struct udata_field_s { - const char *name; - size_t offset; - lua_CFunction getter; - lua_CFunction setter; -} udata_field_t; - -// Simple setters and getters, for situations where getter is simply -// "return obj.field" and setter is "obj.field = value" -int udatalib_getter_fixed(lua_State *L); -int udatalib_getter_angle(lua_State *L); -int udatalib_getter_uint8(lua_State *L); -int udatalib_getter_sint8(lua_State *L); -int udatalib_getter_uint16(lua_State *L); -int udatalib_getter_int16(lua_State *L); -int udatalib_getter_uint32(lua_State *L); -int udatalib_getter_int32(lua_State *L); -int udatalib_getter_uint64(lua_State *L); -int udatalib_getter_int64(lua_State *L); -int udatalib_getter_string(lua_State *L); -int udatalib_getter_boolean(lua_State *L); -int udatalib_getter_spritenum(lua_State *L); -int udatalib_getter_mobj(lua_State *L); -int udatalib_getter_subsector(lua_State *L); -int udatalib_getter_mobjtype(lua_State *L); -int udatalib_getter_player(lua_State *L); -int udatalib_getter_mapthing(lua_State *L); -int udatalib_getter_slope(lua_State *L); -int udatalib_getter_cmd(lua_State *L); -int udatalib_getter_playerstate(lua_State *L); -int udatalib_getter_powers(lua_State *L); -int udatalib_getter_kartstuff(lua_State *L); -int udatalib_getter_pflags(lua_State *L); -int udatalib_getter_panim(lua_State *L); -int udatalib_getter_tic(lua_State *L); - -int udatalib_setter_fixed(lua_State *L); -int udatalib_setter_angle(lua_State *L); -int udatalib_setter_uint8(lua_State *L); -int udatalib_setter_sint8(lua_State *L); -int udatalib_setter_uint16(lua_State *L); -int udatalib_setter_int16(lua_State *L); -int udatalib_setter_uint32(lua_State *L); -int udatalib_setter_int32(lua_State *L); -int udatalib_setter_uint64(lua_State *L); -int udatalib_setter_int64(lua_State *L); -int udatalib_setter_string(lua_State *L); -int udatalib_setter_boolean(lua_State *L); -int udatalib_setter_boolean_nocheck(lua_State *L); -int udatalib_setter_spritenum(lua_State *L); -int udatalib_setter_mobj(lua_State *L); -int udatalib_setter_playerstate(lua_State *L); -int udatalib_setter_pflags(lua_State *L); -int udatalib_setter_panim(lua_State *L); -int udatalib_setter_tic(lua_State *L); - -// Adds setter and getter for field and stores it as field.name..".get" and -// field.name..".set" in table at index mt. (metatable, usually) -void udatalib_addfield(lua_State *L, int mt, udata_field_t field); - -// Convinience function to add array of fields at once. -void udatalib_addfields(lua_State *L, int mt, const udata_field_t fields[]); - -// I miss C++ template functons :( - -// Get pointer to field value within getter or setter -#define UDATALIB_GETFIELD(type, field) \ -{ \ - size_t offset = lua_tointeger(L, lua_upvalueindex(1)); \ - field = (type*)((uint8_t*)lua_touserdata(L, 1) + offset); \ -} - -// Creates implementation for simple getter and setter. Super lazy, yes. -// Assumes userdata is a pointer to actual data. Maybe not really safe. -#define UDATALIB_SIMPLE_GETTER(type, pushf) \ -{ \ - type *field; \ - UDATALIB_GETFIELD(type, field) \ - pushf(L, *field); \ - return 1; \ -} - -#define UDATALIB_SIMPLE_SETTER(type, checkf) \ -{ \ - type *field; \ - UDATALIB_GETFIELD(type, field) \ - *field = checkf(L, 2); \ - return 0; \ -} - -#endif