stjr/SRB2
0
0
Fork 0
mirror of https://git.do.srb2.org/STJr/SRB2.git synced 2024-11-15 01:01:33 +00:00
Code Issues Projects Releases Packages Wiki Activity
SRB2/src/lua_hooklib.c

1730 lines
42 KiB
C
Raw Normal View History

SRB2 2.1 release
2014-03-15 16:59:03 +00:00
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
copyright dates/statements updated and such (no actual SLOC changes)
2016-05-18 00:42:11 +00:00
// Copyright (C) 2012-2016 by John "JTE" Muniz.
Update copyright year to 2020
2020-02-19 22:08:45 +00:00
// Copyright (C) 2012-2020 by Sonic Team Junior.
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
//
// 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_hooklib.c
/// \brief hooks for Lua scripting
#include "doomdef.h"
#include "doomstat.h"
#include "p_mobj.h"
Add hook for chat messages, including csays
2014-06-18 20:28:09 +00:00
#include "g_game.h"
Include r_skins.h instead of r_things.h in many files where all they wanted from it was skins stuff (oddly enough, this actually revealed some secret file dependencies previously included via r_things.h! I also needed to include d_player.h in r_skins.h itself it seems)
2020-03-09 13:54:56 +00:00
#include "r_skins.h"
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
#include "b_bot.h"
#include "z_zone.h"
#include "lua_script.h"
#include "lua_libs.h"
#include "lua_hook.h"
#include "lua_hud.h" // hud_running errors
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
static UINT8 hooksAvailable[(hook_MAX/8)+1];
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
const char *const hookNames[hook_MAX+1] = {
"NetVars",
"MapChange",
"MapLoad",
"PlayerJoin",
Let's try this again!
2019-12-30 04:36:24 +00:00
"PreThinkFrame",
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
"ThinkFrame",
Let's try this again!
2019-12-30 04:36:24 +00:00
"PostThinkFrame",
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
"MobjSpawn",
"MobjCollide",
Add MobjLineCollide hook
2019-12-31 23:17:02 +00:00
"MobjLineCollide",
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
"MobjMoveCollide",
"TouchSpecial",
"MobjFuse",
"MobjThinker",
"BossThinker",
"ShouldDamage",
"MobjDamage",
"MobjDeath",
"BossDeath",
"MobjRemoved",
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
"JumpSpecial",
"AbilitySpecial",
"SpinSpecial",
"JumpSpinSpecial",
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
"BotTiccmd",
"BotAI",
"LinedefExecute",
Add hook for chat messages, including csays
2014-06-18 20:28:09 +00:00
"PlayerMsg",
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
"HurtMsg",
Add PlayerSpawn hook
2016-02-14 11:19:40 +00:00
"PlayerSpawn",
Restructured things so nojumpdamage characters can use the elemental, bubblewrap and attract shields.
2016-10-20 19:55:15 +00:00
"ShieldSpawn",
Adding ShieldSpecial hook. (Activates under different circumstances to the JumpSpinSpecial hook, and can be used to cancel existing shield actions.)
2016-10-24 12:52:36 +00:00
"ShieldSpecial",
Added MobjMoveBlocked Lua hook Also slightly edited P_XYMovement to properly check the mobj still exists before checking its eflags for MFE_SPRUNG, while I was at it
2017-01-21 23:49:18 +00:00
"MobjMoveBlocked",
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
"MapThingSpawn",
Smiles follow-mobj initial support! Still using a Lua hook to follow closely behind, but now it doesn't need to be a generic thinkframe. Woo!
2017-10-02 13:08:58 +00:00
"FollowMobj",
"PlayerCanDamage" hook! * Takes function(player, mo) input. * Return TRUE for stating that yes, the player is in a state that can cause contact damage, do with that what you will. * Return FALSE for stating that no, the player is weak and vulnerable and cannot cause contact damage, do with that what you will. * Return NIL for allowing the function to continue regular operation. Fills a different ideological niche than ShouldDamage - that's for determining whether damage dished between two objects should happen, this is for determining which way around damage should be dished when considering a player-object interaction. Or, in other words, think of it as "ShouldDamage is whether damage that has been requested should be granted, for object-object interaction, while PlayerCanDamage is for whether global player properties should cause damage to enemies and monitors in the first place, like spinning, hammering or stomping."
2019-06-19 11:55:05 +00:00
"PlayerCanDamage",
"PlayerQuit" hook
2016-10-21 02:25:11 +00:00
"PlayerQuit",
New intermission thinker hook
2019-10-14 00:50:46 +00:00
"IntermissionThinker",
TeamSwitch hook for Lua
2019-12-19 02:40:58 +00:00
"TeamSwitch",
ViewpointSwitch hook for Lua
2019-12-18 23:43:54 +00:00
"ViewpointSwitch",
**NEW!** hook_SeenPlayer
2019-12-31 17:37:45 +00:00
"SeenPlayer",
Added PlayerThink hook
2019-12-14 21:28:24 +00:00
"PlayerThink",
Rename hook to ShouldJingleContinue
2020-03-19 03:35:21 +00:00
"ShouldJingleContinue",
Created GameQuit hook, but I need to decide where to execute it
2020-03-12 17:22:04 +00:00
"GameQuit",
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
NULL
};
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
// Hook metadata
struct hook_s
{
struct hook_s *next;
enum hook type;
UINT16 id;
union {
mobjtype_t mt;
char *skinname;
More union types for the union type god
2020-03-19 03:42:31 +00:00
char *musname;
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
char *funcname;
} s;
boolean error;
};
typedef struct hook_s* hook_p;
lua_pushfstring only allows %d not %x Stupid JTE.
2015-06-10 15:06:56 +00:00
#define FMT_HOOKID "hook_%d"
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
// For each mobj type, a linked list to its thinker and collision hooks.
// That way, we don't have to iterate through all the hooks.
// We could do that with all other mobj hooks, but it would probably just be
// a waste of memory since they are only called occasionally. Probably...
static hook_p mobjthinkerhooks[NUMMOBJTYPES];
static hook_p mobjcollidehooks[NUMMOBJTYPES];
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
// For each mobj type, a linked list for other mobj hooks
static hook_p mobjhooks[NUMMOBJTYPES];
// A linked list for player hooks
static hook_p playerhooks;
// A linked list for linedef executor hooks
static hook_p linedefexecutorhooks;
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
// For other hooks, a unique linked list
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p roothook;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
// Takes hook, function, and additional arguments (mobj type to act on, etc.)
static int lib_addHook(lua_State *L)
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
static struct hook_s hook = {NULL, 0, 0, {0}, false};
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
static UINT32 nextid;
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp, *lastp;
hook.type = luaL_checkoption(L, 1, NULL, hookNames);
lua_remove(L, 1);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
luaL_checktype(L, 1, LUA_TFUNCTION);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Added the "lua_lumploading" variable for restricting certain Lua functions to lump load time only
2017-04-25 20:45:53 +00:00
if (!lua_lumploading)
return luaL_error(L, "This function cannot be called from within a hook or coroutine!");
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
switch(hook.type)
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{
// Take a mobjtype enum which this hook is specifically for.
case hook_MobjSpawn:
case hook_MobjCollide:
Add MobjLineCollide hook
2019-12-31 23:17:02 +00:00
case hook_MobjLineCollide:
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
case hook_MobjMoveCollide:
case hook_TouchSpecial:
case hook_MobjFuse:
case hook_MobjThinker:
case hook_BossThinker:
case hook_ShouldDamage:
case hook_MobjDamage:
case hook_MobjDeath:
case hook_BossDeath:
case hook_MobjRemoved:
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
case hook_HurtMsg:
Added MobjMoveBlocked Lua hook Also slightly edited P_XYMovement to properly check the mobj still exists before checking its eflags for MFE_SPRUNG, while I was at it
2017-01-21 23:49:18 +00:00
case hook_MobjMoveBlocked:
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
case hook_MapThingSpawn:
Make hook_FollowMobj a mobj hook instead of a player hook Makes more logical sense, as if you have a custom follow item for a custom skin, you probably want your new thinker to only run for your new MT_ and not the vanilla ones.
2020-02-20 21:40:39 +00:00
case hook_FollowMobj:
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook.s.mt = MT_NULL;
if (lua_isnumber(L, 2))
hook.s.mt = lua_tonumber(L, 2);
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
luaL_argcheck(L, hook.s.mt < NUMMOBJTYPES, 2, "invalid mobjtype_t");
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
break;
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
case hook_BotAI:
Rename hook to ShouldJingleContinue
2020-03-19 03:35:21 +00:00
case hook_ShouldJingleContinue:
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook.s.skinname = NULL;
if (lua_isstring(L, 2))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{ // lowercase copy
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
const char *s = lua_tostring(L, 2);
char *p = hook.s.skinname = ZZ_Alloc(strlen(s)+1);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
do {
*p = tolower(*s);
++p;
} while(*(++s));
*p = 0;
}
break;
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
case hook_LinedefExecute: // Linedef executor functions
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{ // uppercase copy
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
const char *s = luaL_checkstring(L, 2);
char *p = hook.s.funcname = ZZ_Alloc(strlen(s)+1);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
do {
*p = toupper(*s);
++p;
} while(*(++s));
*p = 0;
}
break;
default:
break;
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
lua_settop(L, 1); // lua stack contains only the function now.
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hooksAvailable[hook.type/8] |= 1<<(hook.type%8);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
// set hook.id to the highest id + 1
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
hook.id = nextid++;
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
// Special cases for some hook types (see the comments above mobjthinkerhooks declaration)
switch(hook.type)
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
case hook_MobjThinker:
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
lastp = &mobjthinkerhooks[hook.s.mt];
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
break;
case hook_MobjCollide:
Add MobjLineCollide hook
2019-12-31 23:17:02 +00:00
case hook_MobjLineCollide:
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
case hook_MobjMoveCollide:
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
lastp = &mobjcollidehooks[hook.s.mt];
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
break;
case hook_MobjSpawn:
case hook_TouchSpecial:
case hook_MobjFuse:
case hook_BossThinker:
case hook_ShouldDamage:
case hook_MobjDamage:
case hook_MobjDeath:
case hook_BossDeath:
case hook_MobjRemoved:
Added MobjMoveBlocked Lua hook Also slightly edited P_XYMovement to properly check the mobj still exists before checking its eflags for MFE_SPRUNG, while I was at it
2017-01-21 23:49:18 +00:00
case hook_MobjMoveBlocked:
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
case hook_MapThingSpawn:
Make hook_FollowMobj a mobj hook instead of a player hook Makes more logical sense, as if you have a custom follow item for a custom skin, you probably want your new thinker to only run for your new MT_ and not the vanilla ones.
2020-02-20 21:40:39 +00:00
case hook_FollowMobj:
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
lastp = &mobjhooks[hook.s.mt];
break;
case hook_JumpSpecial:
case hook_AbilitySpecial:
case hook_SpinSpecial:
case hook_JumpSpinSpecial:
case hook_PlayerSpawn:
"PlayerCanDamage" hook! * Takes function(player, mo) input. * Return TRUE for stating that yes, the player is in a state that can cause contact damage, do with that what you will. * Return FALSE for stating that no, the player is weak and vulnerable and cannot cause contact damage, do with that what you will. * Return NIL for allowing the function to continue regular operation. Fills a different ideological niche than ShouldDamage - that's for determining whether damage dished between two objects should happen, this is for determining which way around damage should be dished when considering a player-object interaction. Or, in other words, think of it as "ShouldDamage is whether damage that has been requested should be granted, for object-object interaction, while PlayerCanDamage is for whether global player properties should cause damage to enemies and monitors in the first place, like spinning, hammering or stomping."
2019-06-19 11:55:05 +00:00
case hook_PlayerCanDamage:
TeamSwitch hook for Lua
2019-12-19 02:40:58 +00:00
case hook_TeamSwitch:
ViewpointSwitch hook for Lua
2019-12-18 23:43:54 +00:00
case hook_ViewpointSwitch:
**NEW!** hook_SeenPlayer
2019-12-31 17:37:45 +00:00
case hook_SeenPlayer:
Fixed the shield spawn/special hook cases on the hook add switch. They basically work now. Signed-off-by: Nev3r <apophycens@gmail.com>
2018-12-24 16:31:00 +00:00
case hook_ShieldSpawn:
case hook_ShieldSpecial:
Added PlayerThink hook
2019-12-14 21:28:24 +00:00
case hook_PlayerThink:
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
lastp = &playerhooks;
break;
case hook_LinedefExecute:
lastp = &linedefexecutorhooks;
break;
default:
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
lastp = &roothook;
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
break;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
// iterate the hook metadata structs
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
// set lastp to the last hook struct's "next" pointer.
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
for (hookp = *lastp; hookp; hookp = hookp->next)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
lastp = &hookp->next;
// allocate a permanent memory struct to stuff hook.
hookp = ZZ_Alloc(sizeof(struct hook_s));
memcpy(hookp, &hook, sizeof(struct hook_s));
// tack it onto the end of the linked list.
*lastp = hookp;
// set the hook function in the registry.
lua_pushfstring(L, FMT_HOOKID, hook.id);
lua_pushvalue(L, 1);
lua_settable(L, LUA_REGISTRYINDEX);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return 0;
}
int LUA_HookLib(lua_State *L)
{
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
memset(hooksAvailable,0,sizeof(UINT8[(hook_MAX/8)+1]));
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
roothook = NULL;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
lua_register(L, "addHook", lib_addHook);
return 0;
}
boolean LUAh_MobjHook(mobj_t *mo, enum hook which)
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
boolean hooked = false;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[which/8] & (1<<(which%8))))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return false;
Added a bunch of I_Asserts to lua_hooklib.c relating to mobj types just in case
2017-12-17 20:59:24 +00:00
I_Assert(mo->type < NUMMOBJTYPES);
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
// Look for all generic mobj hooks
for (hookp = mobjhooks[MT_NULL]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != which)
continue;
if (lua_gettop(gL) == 0)
LUA_PushUserdata(gL, mo, META_MOBJ);
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -2);
if (lua_pcall(gL, 1, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
for (hookp = mobjhooks[mo->type]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != which)
continue;
if (lua_gettop(gL) == 0)
LUA_PushUserdata(gL, mo, META_MOBJ);
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -2);
if (lua_pcall(gL, 1, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return hooked;
}
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
boolean LUAh_PlayerHook(player_t *plr, enum hook which)
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
boolean hooked = false;
if (!gL || !(hooksAvailable[which/8] & (1<<(which%8))))
return false;
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
for (hookp = playerhooks; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != which)
continue;
if (lua_gettop(gL) == 0)
LUA_PushUserdata(gL, plr, META_PLAYER);
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -2);
if (lua_pcall(gL, 1, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
return hooked;
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
// Hook for map change (before load)
Change MapChange so Lua returns the map number you change
2018-11-30 17:01:40 +00:00
void LUAh_MapChange(INT16 mapnumber)
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[hook_MapChange/8] & (1<<(hook_MapChange%8))))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return;
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Change MapChange so Lua returns the map number you change
2018-11-30 17:01:40 +00:00
lua_pushinteger(gL, mapnumber);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_MapChange)
continue;
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -2);
LUA_Call(gL, 1);
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
// Hook for map load
void LUAh_MapLoad(void)
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[hook_MapLoad/8] & (1<<(hook_MapLoad%8))))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return;
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
lua_pushinteger(gL, gamemap);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_MapLoad)
continue;
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -2);
LUA_Call(gL, 1);
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
// Hook for Got_AddPlayer
void LUAh_PlayerJoin(int playernum)
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[hook_PlayerJoin/8] & (1<<(hook_PlayerJoin%8))))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return;
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
lua_pushinteger(gL, playernum);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_PlayerJoin)
continue;
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -2);
LUA_Call(gL, 1);
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Let's try this again!
2019-12-30 04:36:24 +00:00
// Hook for frame (before mobj and player thinkers)
void LUAh_PreThinkFrame(void)
{
hook_p hookp;
if (!gL || !(hooksAvailable[hook_PreThinkFrame/8] & (1<<(hook_PreThinkFrame%8))))
return;
for (hookp = roothook; hookp; hookp = hookp->next)
{
if (hookp->type != hook_PreThinkFrame)
continue;
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
if (lua_pcall(gL, 0, 0, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
}
}
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
// Hook for frame (after mobj and player thinkers)
void LUAh_ThinkFrame(void)
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[hook_ThinkFrame/8] & (1<<(hook_ThinkFrame%8))))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return;
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_ThinkFrame)
continue;
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
if (lua_pcall(gL, 0, 0, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Revert changes to searchBlockmap because on reflection, the benefits didn't outweigh breaking every current usage of it Readd ThinkFrame in its original position PostThinkFrame now runs at the end of P_Ticker, only MapEnd runs after it
2019-12-31 03:04:27 +00:00
// Hook for frame (at end of tick, ie after overlays, precipitation, specials)
Let's try this again!
2019-12-30 04:36:24 +00:00
void LUAh_PostThinkFrame(void)
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
Let's try this again!
2019-12-30 04:36:24 +00:00
if (!gL || !(hooksAvailable[hook_PostThinkFrame/8] & (1<<(hook_PostThinkFrame%8))))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return;
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
Let's try this again!
2019-12-30 04:36:24 +00:00
if (hookp->type != hook_PostThinkFrame)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
continue;
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
if (lua_pcall(gL, 0, 0, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
// Hook for mobj collisions
UINT8 LUAh_MobjCollideHook(mobj_t *thing1, mobj_t *thing2, enum hook which)
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
UINT8 shouldCollide = 0; // 0 = default, 1 = force yes, 2 = force no.
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
if (!gL || !(hooksAvailable[which/8] & (1<<(which%8))))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return 0;
Added a bunch of I_Asserts to lua_hooklib.c relating to mobj types just in case
2017-12-17 20:59:24 +00:00
I_Assert(thing1->type < NUMMOBJTYPES);
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
// Look for all generic mobj collision hooks
for (hookp = mobjcollidehooks[MT_NULL]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != which)
continue;
if (lua_gettop(gL) == 0)
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, thing1, META_MOBJ);
LUA_PushUserdata(gL, thing2, META_MOBJ);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (!lua_isnil(gL, -1))
{ // if nil, leave shouldCollide = 0.
if (lua_toboolean(gL, -1))
shouldCollide = 1; // Force yes
else
shouldCollide = 2; // Force no
}
lua_pop(gL, 1);
}
MobjThinker, MobjCollide and MobjMoveCollide hooks are now directly linked to the mobjtype they belong to, so you no longer iterate through all existing hooks.
2016-11-04 17:56:25 +00:00
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
for (hookp = mobjcollidehooks[thing1->type]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != which)
continue;
if (lua_gettop(gL) == 0)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, thing1, META_MOBJ);
LUA_PushUserdata(gL, thing2, META_MOBJ);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (!lua_isnil(gL, -1))
{ // if nil, leave shouldCollide = 0.
if (lua_toboolean(gL, -1))
shouldCollide = 1; // Force yes
else
shouldCollide = 2; // Force no
}
lua_pop(gL, 1);
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return shouldCollide;
}
Add MobjLineCollide hook
2019-12-31 23:17:02 +00:00
UINT8 LUAh_MobjLineCollideHook(mobj_t *thing, line_t *line, enum hook which)
{
hook_p hookp;
UINT8 shouldCollide = 0; // 0 = default, 1 = force yes, 2 = force no.
if (!gL || !(hooksAvailable[which/8] & (1<<(which%8))))
return 0;
I_Assert(thing->type < NUMMOBJTYPES);
lua_settop(gL, 0);
// Look for all generic mobj collision hooks
for (hookp = mobjcollidehooks[MT_NULL]; hookp; hookp = hookp->next)
{
if (hookp->type != which)
continue;
if (lua_gettop(gL) == 0)
{
LUA_PushUserdata(gL, thing, META_MOBJ);
LUA_PushUserdata(gL, line, META_LINE);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
if (!lua_isnil(gL, -1))
{ // if nil, leave shouldCollide = 0.
if (lua_toboolean(gL, -1))
shouldCollide = 1; // Force yes
else
shouldCollide = 2; // Force no
}
lua_pop(gL, 1);
}
for (hookp = mobjcollidehooks[thing->type]; hookp; hookp = hookp->next)
{
if (hookp->type != which)
continue;
if (lua_gettop(gL) == 0)
{
LUA_PushUserdata(gL, thing, META_MOBJ);
LUA_PushUserdata(gL, line, META_LINE);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
if (!lua_isnil(gL, -1))
{ // if nil, leave shouldCollide = 0.
if (lua_toboolean(gL, -1))
shouldCollide = 1; // Force yes
else
shouldCollide = 2; // Force no
}
lua_pop(gL, 1);
}
lua_settop(gL, 0);
return shouldCollide;
}
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
// Hook for mobj thinkers
boolean LUAh_MobjThinker(mobj_t *mo)
{
hook_p hookp;
boolean hooked = false;
if (!gL || !(hooksAvailable[hook_MobjThinker/8] & (1<<(hook_MobjThinker%8))))
return false;
Added a bunch of I_Asserts to lua_hooklib.c relating to mobj types just in case
2017-12-17 20:59:24 +00:00
I_Assert(mo->type < NUMMOBJTYPES);
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
lua_settop(gL, 0);
// Look for all generic mobj thinker hooks
for (hookp = mobjthinkerhooks[MT_NULL]; hookp; hookp = hookp->next)
{
if (lua_gettop(gL) == 0)
LUA_PushUserdata(gL, mo, META_MOBJ);
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -2);
if (lua_pcall(gL, 1, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
for (hookp = mobjthinkerhooks[mo->type]; hookp; hookp = hookp->next)
{
if (lua_gettop(gL) == 0)
LUA_PushUserdata(gL, mo, META_MOBJ);
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -2);
if (lua_pcall(gL, 1, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
lua_settop(gL, 0);
return hooked;
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
// Hook for P_TouchSpecialThing by mobj type
boolean LUAh_TouchSpecial(mobj_t *special, mobj_t *toucher)
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
boolean hooked = false;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[hook_TouchSpecial/8] & (1<<(hook_TouchSpecial%8))))
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
return 0;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Added a bunch of I_Asserts to lua_hooklib.c relating to mobj types just in case
2017-12-17 20:59:24 +00:00
I_Assert(special->type < NUMMOBJTYPES);
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
// Look for all generic touch special hooks
for (hookp = mobjhooks[MT_NULL]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_TouchSpecial)
continue;
if (lua_gettop(gL) == 0)
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, special, META_MOBJ);
LUA_PushUserdata(gL, toucher, META_MOBJ);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
for (hookp = mobjhooks[special->type]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_TouchSpecial)
continue;
if (lua_gettop(gL) == 0)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, special, META_MOBJ);
LUA_PushUserdata(gL, toucher, META_MOBJ);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return hooked;
}
// Hook for P_DamageMobj by mobj type (Should mobj take damage?)
Add "damagetype" argument to functions for Lua hooks ShouldDamage, MobjDamage, MobjDeath and HurtMsg
2016-07-20 21:02:02 +00:00
UINT8 LUAh_ShouldDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage, UINT8 damagetype)
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
UINT8 shouldDamage = 0; // 0 = default, 1 = force yes, 2 = force no.
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[hook_ShouldDamage/8] & (1<<(hook_ShouldDamage%8))))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return 0;
Added a bunch of I_Asserts to lua_hooklib.c relating to mobj types just in case
2017-12-17 20:59:24 +00:00
I_Assert(target->type < NUMMOBJTYPES);
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
// Look for all generic should damage hooks
for (hookp = mobjhooks[MT_NULL]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_ShouldDamage)
continue;
if (lua_gettop(gL) == 0)
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, target, META_MOBJ);
LUA_PushUserdata(gL, inflictor, META_MOBJ);
LUA_PushUserdata(gL, source, META_MOBJ);
lua_pushinteger(gL, damage);
Fix ShouldDamage, MobjDamage and MobjDeath hooks all messing up the pushing of variables to Lua as function args, by adding damagetype support where it was missing! The above issue occured only if you had both a generic hook and a type specific hook for a particular hook type. This way, the stack is never updated to include damagetype at the start, and all pushes of the variables get offsetted by 1 compared to what they should be, once the code *expects* damagetype to be included in it.
2019-12-25 21:48:59 +00:00
lua_pushinteger(gL, damagetype);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
Fix ShouldDamage, MobjDamage and MobjDeath hooks all messing up the pushing of variables to Lua as function args, by adding damagetype support where it was missing! The above issue occured only if you had both a generic hook and a type specific hook for a particular hook type. This way, the stack is never updated to include damagetype at the start, and all pushes of the variables get offsetted by 1 compared to what they should be, once the code *expects* damagetype to be included in it.
2019-12-25 21:48:59 +00:00
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
if (lua_pcall(gL, 5, 1, 0)) {
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (!lua_isnil(gL, -1))
{
if (lua_toboolean(gL, -1))
shouldDamage = 1; // Force yes
else
shouldDamage = 2; // Force no
}
lua_pop(gL, 1);
}
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
for (hookp = mobjhooks[target->type]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_ShouldDamage)
continue;
if (lua_gettop(gL) == 0)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, target, META_MOBJ);
LUA_PushUserdata(gL, inflictor, META_MOBJ);
LUA_PushUserdata(gL, source, META_MOBJ);
lua_pushinteger(gL, damage);
lua_pushinteger(gL, damagetype);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
if (lua_pcall(gL, 5, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (!lua_isnil(gL, -1))
{
if (lua_toboolean(gL, -1))
shouldDamage = 1; // Force yes
else
shouldDamage = 2; // Force no
}
lua_pop(gL, 1);
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return shouldDamage;
}
// Hook for P_DamageMobj by mobj type (Mobj actually takes damage!)
Add "damagetype" argument to functions for Lua hooks ShouldDamage, MobjDamage, MobjDeath and HurtMsg
2016-07-20 21:02:02 +00:00
boolean LUAh_MobjDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage, UINT8 damagetype)
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
boolean hooked = false;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[hook_MobjDamage/8] & (1<<(hook_MobjDamage%8))))
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
return 0;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Added a bunch of I_Asserts to lua_hooklib.c relating to mobj types just in case
2017-12-17 20:59:24 +00:00
I_Assert(target->type < NUMMOBJTYPES);
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
// Look for all generic mobj damage hooks
for (hookp = mobjhooks[MT_NULL]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_MobjDamage)
continue;
if (lua_gettop(gL) == 0)
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, target, META_MOBJ);
LUA_PushUserdata(gL, inflictor, META_MOBJ);
LUA_PushUserdata(gL, source, META_MOBJ);
lua_pushinteger(gL, damage);
Fix ShouldDamage, MobjDamage and MobjDeath hooks all messing up the pushing of variables to Lua as function args, by adding damagetype support where it was missing! The above issue occured only if you had both a generic hook and a type specific hook for a particular hook type. This way, the stack is never updated to include damagetype at the start, and all pushes of the variables get offsetted by 1 compared to what they should be, once the code *expects* damagetype to be included in it.
2019-12-25 21:48:59 +00:00
lua_pushinteger(gL, damagetype);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
Fix ShouldDamage, MobjDamage and MobjDeath hooks all messing up the pushing of variables to Lua as function args, by adding damagetype support where it was missing! The above issue occured only if you had both a generic hook and a type specific hook for a particular hook type. This way, the stack is never updated to include damagetype at the start, and all pushes of the variables get offsetted by 1 compared to what they should be, once the code *expects* damagetype to be included in it.
2019-12-25 21:48:59 +00:00
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
if (lua_pcall(gL, 5, 1, 0)) {
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
for (hookp = mobjhooks[target->type]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_MobjDamage)
continue;
if (lua_gettop(gL) == 0)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, target, META_MOBJ);
LUA_PushUserdata(gL, inflictor, META_MOBJ);
LUA_PushUserdata(gL, source, META_MOBJ);
lua_pushinteger(gL, damage);
lua_pushinteger(gL, damagetype);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
if (lua_pcall(gL, 5, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
return hooked;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
// Hook for P_KillMobj by mobj type
Add "damagetype" argument to functions for Lua hooks ShouldDamage, MobjDamage, MobjDeath and HurtMsg
2016-07-20 21:02:02 +00:00
boolean LUAh_MobjDeath(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damagetype)
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
boolean hooked = false;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[hook_MobjDeath/8] & (1<<(hook_MobjDeath%8))))
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
return 0;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Added a bunch of I_Asserts to lua_hooklib.c relating to mobj types just in case
2017-12-17 20:59:24 +00:00
I_Assert(target->type < NUMMOBJTYPES);
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
// Look for all generic mobj death hooks
for (hookp = mobjhooks[MT_NULL]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_MobjDeath)
continue;
if (lua_gettop(gL) == 0)
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, target, META_MOBJ);
LUA_PushUserdata(gL, inflictor, META_MOBJ);
LUA_PushUserdata(gL, source, META_MOBJ);
Fix ShouldDamage, MobjDamage and MobjDeath hooks all messing up the pushing of variables to Lua as function args, by adding damagetype support where it was missing! The above issue occured only if you had both a generic hook and a type specific hook for a particular hook type. This way, the stack is never updated to include damagetype at the start, and all pushes of the variables get offsetted by 1 compared to what they should be, once the code *expects* damagetype to be included in it.
2019-12-25 21:48:59 +00:00
lua_pushinteger(gL, damagetype);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
Fix ShouldDamage, MobjDamage and MobjDeath hooks all messing up the pushing of variables to Lua as function args, by adding damagetype support where it was missing! The above issue occured only if you had both a generic hook and a type specific hook for a particular hook type. This way, the stack is never updated to include damagetype at the start, and all pushes of the variables get offsetted by 1 compared to what they should be, once the code *expects* damagetype to be included in it.
2019-12-25 21:48:59 +00:00
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
if (lua_pcall(gL, 4, 1, 0)) {
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
for (hookp = mobjhooks[target->type]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_MobjDeath)
continue;
if (lua_gettop(gL) == 0)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, target, META_MOBJ);
LUA_PushUserdata(gL, inflictor, META_MOBJ);
LUA_PushUserdata(gL, source, META_MOBJ);
lua_pushinteger(gL, damagetype);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
if (lua_pcall(gL, 4, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
return hooked;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
// Hook for B_BuildTiccmd
boolean LUAh_BotTiccmd(player_t *bot, ticcmd_t *cmd)
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
boolean hooked = false;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[hook_BotTiccmd/8] & (1<<(hook_BotTiccmd%8))))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return false;
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_BotTiccmd)
continue;
if (lua_gettop(gL) == 0)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, bot, META_PLAYER);
LUA_PushUserdata(gL, cmd, META_TICCMD);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return hooked;
}
// Hook for B_BuildTailsTiccmd by skin name
boolean LUAh_BotAI(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
boolean hooked = false;
if (!gL || !(hooksAvailable[hook_BotAI/8] & (1<<(hook_BotAI%8))))
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
return false;
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_BotAI
|| (hookp->s.skinname && strcmp(hookp->s.skinname, ((skin_t*)tails->skin)->name)))
continue;
if (lua_gettop(gL) == 0)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, sonic, META_MOBJ);
LUA_PushUserdata(gL, tails, META_MOBJ);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 8, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
// This turns forward, backward, left, right, jump, and spin into a proper ticcmd for tails.
if (lua_istable(gL, 2+1)) {
boolean forward=false, backward=false, left=false, right=false, strafeleft=false, straferight=false, jump=false, spin=false;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
#define CHECKFIELD(field) \
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
lua_getfield(gL, 2+1, #field);\
if (lua_toboolean(gL, -1))\
field = true;\
lua_pop(gL, 1);
CHECKFIELD(forward)
CHECKFIELD(backward)
CHECKFIELD(left)
CHECKFIELD(right)
CHECKFIELD(strafeleft)
CHECKFIELD(straferight)
CHECKFIELD(jump)
CHECKFIELD(spin)
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
#undef CHECKFIELD
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
B_KeysToTiccmd(tails, cmd, forward, backward, left, right, strafeleft, straferight, jump, spin);
} else
B_KeysToTiccmd(tails, cmd, lua_toboolean(gL, 2+1), lua_toboolean(gL, 2+2), lua_toboolean(gL, 2+3), lua_toboolean(gL, 2+4), lua_toboolean(gL, 2+5), lua_toboolean(gL, 2+6), lua_toboolean(gL, 2+7), lua_toboolean(gL, 2+8));
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
lua_pop(gL, 8);
hooked = true;
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
return hooked;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
// Hook for linedef executors
SRB2 2.1.12 release
2014-11-12 00:55:07 +00:00
boolean LUAh_LinedefExecute(line_t *line, mobj_t *mo, sector_t *sector)
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
boolean hooked = false;
SRB2 2.1.7 release
2014-04-14 05:14:58 +00:00
if (!gL || !(hooksAvailable[hook_LinedefExecute/8] & (1<<(hook_LinedefExecute%8))))
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
return 0;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
Generic mobj hooks are now run before mobjtype-specific mobj hooks, and player/linedef executor hooks now have their own lists
2016-12-15 20:05:54 +00:00
for (hookp = linedefexecutorhooks; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (strcmp(hookp->s.funcname, line->text))
continue;
if (lua_gettop(gL) == 0)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, line, META_LINE);
LUA_PushUserdata(gL, mo, META_MOBJ);
LUA_PushUserdata(gL, sector, META_SECTOR);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -4);
lua_pushvalue(gL, -4);
lua_pushvalue(gL, -4);
LUA_Call(gL, 3);
hooked = true;
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
return hooked;
SRB2 2.1 release
2014-03-15 16:59:03 +00:00
}
Remove mute boolean from playermsg hook, fix username stuff still being there, potential memory leaks, and added back the ip message.
2018-12-22 15:44:58 +00:00
Add hook for chat messages, including csays
2014-06-18 20:28:09 +00:00
boolean LUAh_PlayerMsg(int source, int target, int flags, char *msg)
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
boolean hooked = false;
Add hook for chat messages, including csays
2014-06-18 20:28:09 +00:00
if (!gL || !(hooksAvailable[hook_PlayerMsg/8] & (1<<(hook_PlayerMsg%8))))
return false;
Merge remote-tracking branch 'RedEnchilada/next' into next Also clean up whitespaces
2014-06-19 16:59:15 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Merge remote-tracking branch 'RedEnchilada/next' into next Also clean up whitespaces
2014-06-19 16:59:15 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_PlayerMsg)
continue;
if (lua_gettop(gL) == 0)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, &players[source], META_PLAYER); // Source player
if (flags & 2 /*HU_CSAY*/) { // csay TODO: make HU_CSAY accessible outside hu_stuff.c
lua_pushinteger(gL, 3); // type
lua_pushnil(gL); // target
} else if (target == -1) { // sayteam
lua_pushinteger(gL, 1); // type
lua_pushnil(gL); // target
} else if (target == 0) { // say
lua_pushinteger(gL, 0); // type
lua_pushnil(gL); // target
} else { // sayto
lua_pushinteger(gL, 2); // type
LUA_PushUserdata(gL, &players[target-1], META_PLAYER); // target
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
lua_pushstring(gL, msg); // msg
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
if (lua_pcall(gL, 4, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
Add hook for chat messages, including csays
2014-06-18 20:28:09 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
Add hook for chat messages, including csays
2014-06-18 20:28:09 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
return hooked;
Add hook for chat messages, including csays
2014-06-18 20:28:09 +00:00
}
2.1.21 and all of the kart additions. Woo.
2018-12-17 19:43:59 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
// Hook for hurt messages
Add "damagetype" argument to functions for Lua hooks ShouldDamage, MobjDamage, MobjDeath and HurtMsg
2016-07-20 21:02:02 +00:00
boolean LUAh_HurtMsg(player_t *player, mobj_t *inflictor, mobj_t *source, UINT8 damagetype)
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
{
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
hook_p hookp;
boolean hooked = false;
if (!gL || !(hooksAvailable[hook_HurtMsg/8] & (1<<(hook_HurtMsg%8))))
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
return false;
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_HurtMsg
|| (hookp->s.mt && !(inflictor && hookp->s.mt == inflictor->type)))
continue;
if (lua_gettop(gL) == 0)
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, player, META_PLAYER);
LUA_PushUserdata(gL, inflictor, META_MOBJ);
LUA_PushUserdata(gL, source, META_MOBJ);
lua_pushinteger(gL, damagetype);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
lua_pushvalue(gL, -5);
if (lua_pcall(gL, 4, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
Only push userdata to the stack when needed!! Dummy, what do you think you're doing? If you just push mobjs and players into Lua all willy- nilly everywhere, you'll wind up generating tons of metatables and stuff you arne't even gonna use! Oh. Thanks me, I'm really smart.
2015-06-10 12:06:16 +00:00
lua_settop(gL, 0);
Rewrote the entirety of lua_hooklib.c This _should_ solve some significant performance issues Lua experiences. If not, I will be very upset for having wasted so much time and effort. There will be bugs, this kind of thing needs to be thuroughly tested and this is just the first iteration of it.
2015-06-10 11:28:09 +00:00
return hooked;
SRB2 2.1.9 release
2014-08-04 03:49:33 +00:00
}
Updated NetArchiveHook to lua_hooklib.c Fixes I_Assert failure crash due to hooks working differently now.
2016-03-03 22:07:05 +00:00
void LUAh_NetArchiveHook(lua_CFunction archFunc)
{
hook_p hookp;
if (!gL || !(hooksAvailable[hook_NetVars/8] & (1<<(hook_NetVars%8))))
return;
// stack: tables
I_Assert(lua_gettop(gL) > 0);
I_Assert(lua_istable(gL, -1));
Fix bad logic in LUAh_NetArchiveHook rewrite... Argh, I knew I was forgetting something! archFunc is the argument to be passed to the hooks, not tables!
2016-03-03 22:30:46 +00:00
// tables becomes an upvalue of archFunc
lua_pushvalue(gL, -1);
lua_pushcclosure(gL, archFunc, 1);
// stack: tables, archFunc
Updated NetArchiveHook to lua_hooklib.c Fixes I_Assert failure crash due to hooks working differently now.
2016-03-03 22:07:05 +00:00
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_NetVars)
continue;
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -2); // archFunc
LUA_Call(gL, 1);
}
Updated NetArchiveHook to lua_hooklib.c Fixes I_Assert failure crash due to hooks working differently now.
2016-03-03 22:07:05 +00:00
Fix bad logic in LUAh_NetArchiveHook rewrite... Argh, I knew I was forgetting something! archFunc is the argument to be passed to the hooks, not tables!
2016-03-03 22:30:46 +00:00
lua_pop(gL, 1); // pop archFunc
Fix errenous stack pop. This function is intended to leave the stack in the same state it recieved it.
2016-03-03 22:19:21 +00:00
// stack: tables
Updated NetArchiveHook to lua_hooklib.c Fixes I_Assert failure crash due to hooks working differently now.
2016-03-03 22:07:05 +00:00
}
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
boolean LUAh_MapThingSpawn(mobj_t *mo, mapthing_t *mthing)
{
hook_p hookp;
boolean hooked = false;
if (!gL || !(hooksAvailable[hook_MapThingSpawn/8] & (1<<(hook_MapThingSpawn%8))))
return false;
lua_settop(gL, 0);
// Look for all generic mobj map thing spawn hooks
for (hookp = mobjhooks[MT_NULL]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_MapThingSpawn)
continue;
if (lua_gettop(gL) == 0)
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, mo, META_MOBJ);
LUA_PushUserdata(gL, mthing, META_MAPTHING);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
for (hookp = mobjhooks[mo->type]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_MapThingSpawn)
continue;
if (lua_gettop(gL) == 0)
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, mo, META_MOBJ);
LUA_PushUserdata(gL, mthing, META_MAPTHING);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
Add the "MapThingSpawn" hook to Lua
2017-04-15 20:41:22 +00:00
lua_settop(gL, 0);
return hooked;
}
Smiles follow-mobj initial support! Still using a Lua hook to follow closely behind, but now it doesn't need to be a generic thinkframe. Woo!
2017-10-02 13:08:58 +00:00
// Hook for P_PlayerAfterThink Smiles mobj-following
boolean LUAh_FollowMobj(player_t *player, mobj_t *mobj)
{
hook_p hookp;
boolean hooked = false;
if (!gL || !(hooksAvailable[hook_FollowMobj/8] & (1<<(hook_FollowMobj%8))))
return 0;
lua_settop(gL, 0);
Make hook_FollowMobj a mobj hook instead of a player hook Makes more logical sense, as if you have a custom follow item for a custom skin, you probably want your new thinker to only run for your new MT_ and not the vanilla ones.
2020-02-20 21:40:39 +00:00
// Look for all generic mobj follow item hooks
for (hookp = mobjhooks[MT_NULL]; hookp; hookp = hookp->next)
{
if (hookp->type != hook_FollowMobj)
continue;
if (lua_gettop(gL) == 0)
{
LUA_PushUserdata(gL, player, META_PLAYER);
LUA_PushUserdata(gL, mobj, META_MOBJ);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
for (hookp = mobjhooks[mobj->type]; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_FollowMobj)
continue;
if (lua_gettop(gL) == 0)
Smiles follow-mobj initial support! Still using a Lua hook to follow closely behind, but now it doesn't need to be a generic thinkframe. Woo!
2017-10-02 13:08:58 +00:00
{
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
LUA_PushUserdata(gL, player, META_PLAYER);
LUA_PushUserdata(gL, mobj, META_MOBJ);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
Smiles follow-mobj initial support! Still using a Lua hook to follow closely behind, but now it doesn't need to be a generic thinkframe. Woo!
2017-10-02 13:08:58 +00:00
lua_pop(gL, 1);
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
hookp->error = true;
continue;
Smiles follow-mobj initial support! Still using a Lua hook to follow closely behind, but now it doesn't need to be a generic thinkframe. Woo!
2017-10-02 13:08:58 +00:00
}
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
if (lua_toboolean(gL, -1))
hooked = true;
lua_pop(gL, 1);
}
Smiles follow-mobj initial support! Still using a Lua hook to follow closely behind, but now it doesn't need to be a generic thinkframe. Woo!
2017-10-02 13:08:58 +00:00
lua_settop(gL, 0);
return hooked;
}
"PlayerCanDamage" hook! * Takes function(player, mo) input. * Return TRUE for stating that yes, the player is in a state that can cause contact damage, do with that what you will. * Return FALSE for stating that no, the player is weak and vulnerable and cannot cause contact damage, do with that what you will. * Return NIL for allowing the function to continue regular operation. Fills a different ideological niche than ShouldDamage - that's for determining whether damage dished between two objects should happen, this is for determining which way around damage should be dished when considering a player-object interaction. Or, in other words, think of it as "ShouldDamage is whether damage that has been requested should be granted, for object-object interaction, while PlayerCanDamage is for whether global player properties should cause damage to enemies and monitors in the first place, like spinning, hammering or stomping."
2019-06-19 11:55:05 +00:00
// Hook for P_PlayerCanDamage
UINT8 LUAh_PlayerCanDamage(player_t *player, mobj_t *mobj)
{
hook_p hookp;
UINT8 shouldCollide = 0; // 0 = default, 1 = force yes, 2 = force no.
if (!gL || !(hooksAvailable[hook_PlayerCanDamage/8] & (1<<(hook_PlayerCanDamage%8))))
return 0;
lua_settop(gL, 0);
for (hookp = playerhooks; hookp; hookp = hookp->next)
{
if (hookp->type != hook_PlayerCanDamage)
continue;
if (lua_gettop(gL) == 0)
{
LUA_PushUserdata(gL, player, META_PLAYER);
LUA_PushUserdata(gL, mobj, META_MOBJ);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
if (!lua_isnil(gL, -1))
{ // if nil, leave shouldCollide = 0.
if (lua_toboolean(gL, -1))
shouldCollide = 1; // Force yes
else
shouldCollide = 2; // Force no
}
lua_pop(gL, 1);
}
lua_settop(gL, 0);
return shouldCollide;
}
Let clients rejoin the server without losing their status This is accomplished by simply preserving the player's body after disconnecting. Bodies will despawn after the number of minutes specified by the "rejointimeout" console variable (float). A value of 0 disables the feature completely. Clients rejoining are identified by their IP address, and may rejoin even if the server is full or joins are disabled, for as long as their body remains. From a technical standpoint, when the user disconnects, the player they were controlling does not leave, the underlying player_t just keeps working normally, except it does not receive any input anymore. When the user reconnects, they are simply "relinked" to their player_t. Those "soulless" players can be identified through their "quittime" field, which is the number of tics elapsed since the user disconnected, or zero if still connected. "quittime" is exposed to Lua.
2020-01-22 02:05:08 +00:00
void LUAh_PlayerQuit(player_t *plr, kickreason_t reason)
"PlayerQuit" hook
2016-10-21 02:25:11 +00:00
{
hook_p hookp;
if (!gL || !(hooksAvailable[hook_PlayerQuit/8] & (1<<(hook_PlayerQuit%8))))
Oops; PlayerQuit isn't a boolean!
2016-10-21 03:26:41 +00:00
return;
"PlayerQuit" hook
2016-10-21 02:25:11 +00:00
lua_settop(gL, 0);
for (hookp = roothook; hookp; hookp = hookp->next)
Instead of only performing a hook if the Lua Hook loop determines its type to be the one we want, actively continue through the loop if it's NOT. This optimisation was performed while preparing the following commit; I have generously split them out for less shitty commit-by-commit review.
2019-06-19 11:28:57 +00:00
{
if (hookp->type != hook_PlayerQuit)
continue;
if (lua_gettop(gL) == 0)
{
LUA_PushUserdata(gL, plr, META_PLAYER); // Player that quit
lua_pushinteger(gL, reason); // Reason for quitting
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
LUA_Call(gL, 2);
}
"PlayerQuit" hook
2016-10-21 02:25:11 +00:00
lua_settop(gL, 0);
}
New intermission thinker hook
2019-10-14 00:50:46 +00:00
// Hook for Y_Ticker
void LUAh_IntermissionThinker(void)
{
hook_p hookp;
if (!gL || !(hooksAvailable[hook_IntermissionThinker/8] & (1<<(hook_IntermissionThinker%8))))
return;
for (hookp = roothook; hookp; hookp = hookp->next)
Change this for consistency.
2019-10-15 01:47:20 +00:00
{
if (hookp->type != hook_IntermissionThinker)
continue;
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
if (lua_pcall(gL, 0, 0, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
New intermission thinker hook
2019-10-14 00:50:46 +00:00
}
Change this for consistency.
2019-10-15 01:47:20 +00:00
}
New intermission thinker hook
2019-10-14 00:50:46 +00:00
}
TeamSwitch hook for Lua
2019-12-19 02:40:58 +00:00
// Hook for team switching
// It's just an edit of LUAh_ViewpointSwitch.
Shadowed variable declarations whoopsie!!! uwu
2019-12-19 02:53:26 +00:00
boolean LUAh_TeamSwitch(player_t *player, int newteam, boolean fromspectators, boolean tryingautobalance, boolean tryingscramble)
TeamSwitch hook for Lua
2019-12-19 02:40:58 +00:00
{
hook_p hookp;
boolean canSwitchTeam = true;
if (!gL || !(hooksAvailable[hook_TeamSwitch/8] & (1<<(hook_TeamSwitch%8))))
De-fuck team change
2019-12-19 03:31:13 +00:00
return true;
TeamSwitch hook for Lua
2019-12-19 02:40:58 +00:00
lua_settop(gL, 0);
for (hookp = playerhooks; hookp; hookp = hookp->next)
{
if (hookp->type != hook_TeamSwitch)
continue;
if (lua_gettop(gL) == 0)
{
LUA_PushUserdata(gL, player, META_PLAYER);
lua_pushinteger(gL, newteam);
lua_pushboolean(gL, fromspectators);
Shadowed variable declarations whoopsie!!! uwu
2019-12-19 02:53:26 +00:00
lua_pushboolean(gL, tryingautobalance);
lua_pushboolean(gL, tryingscramble);
TeamSwitch hook for Lua
2019-12-19 02:40:58 +00:00
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
lua_pushvalue(gL, -6);
if (lua_pcall(gL, 5, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
if (!lua_isnil(gL, -1) && !lua_toboolean(gL, -1))
canSwitchTeam = false; // Can't switch team
lua_pop(gL, 1);
}
lua_settop(gL, 0);
return canSwitchTeam;
}
ViewpointSwitch improvements.
2019-12-23 23:22:57 +00:00
// Hook for spy mode
UINT8 LUAh_ViewpointSwitch(player_t *player, player_t *newdisplayplayer, boolean forced)
ViewpointSwitch hook for Lua
2019-12-18 23:43:54 +00:00
{
hook_p hookp;
UINT8 canSwitchView = 0; // 0 = default, 1 = force yes, 2 = force no.
if (!gL || !(hooksAvailable[hook_ViewpointSwitch/8] & (1<<(hook_ViewpointSwitch%8))))
return 0;
lua_settop(gL, 0);
**NEW!** hook_SeenPlayer
2019-12-31 17:37:45 +00:00
hud_running = true; // local hook
ViewpointSwitch hook for Lua
2019-12-18 23:43:54 +00:00
for (hookp = playerhooks; hookp; hookp = hookp->next)
{
if (hookp->type != hook_ViewpointSwitch)
continue;
if (lua_gettop(gL) == 0)
{
LUA_PushUserdata(gL, player, META_PLAYER);
LUA_PushUserdata(gL, newdisplayplayer, META_PLAYER);
ViewpointSwitch improvements.
2019-12-23 23:22:57 +00:00
lua_pushboolean(gL, forced);
ViewpointSwitch hook for Lua
2019-12-18 23:43:54 +00:00
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
ViewpointSwitch improvements.
2019-12-23 23:22:57 +00:00
lua_pushvalue(gL, -4);
lua_pushvalue(gL, -4);
lua_pushvalue(gL, -4);
if (lua_pcall(gL, 3, 1, 0)) {
ViewpointSwitch hook for Lua
2019-12-18 23:43:54 +00:00
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
if (!lua_isnil(gL, -1))
{ // if nil, leave canSwitchView = 0.
if (lua_toboolean(gL, -1))
canSwitchView = 1; // Force viewpoint switch
else
canSwitchView = 2; // Skip viewpoint switch
}
lua_pop(gL, 1);
}
lua_settop(gL, 0);
ViewpointSwitch hack so nobody does anything evil Prints the generic "can't do this in a HUD hook" message. Whatever. I'm tired.
2019-12-19 02:47:17 +00:00
hud_running = false;
ViewpointSwitch hook for Lua
2019-12-18 23:43:54 +00:00
return canSwitchView;
}
**NEW!** hook_SeenPlayer
2019-12-31 17:37:45 +00:00
// Hook for MT_NAMECHECK
#ifdef SEENAMES
Rename ``seenplayer`` to ``seenfriend``
2020-01-01 18:17:29 +00:00
boolean LUAh_SeenPlayer(player_t *player, player_t *seenfriend)
**NEW!** hook_SeenPlayer
2019-12-31 17:37:45 +00:00
{
hook_p hookp;
boolean hasSeenPlayer = true;
if (!gL || !(hooksAvailable[hook_SeenPlayer/8] & (1<<(hook_SeenPlayer%8))))
Fix LUAh_SeenPlayer not working
2020-02-18 02:06:38 +00:00
return true;
**NEW!** hook_SeenPlayer
2019-12-31 17:37:45 +00:00
lua_settop(gL, 0);
hud_running = true; // local hook
for (hookp = playerhooks; hookp; hookp = hookp->next)
{
if (hookp->type != hook_SeenPlayer)
continue;
if (lua_gettop(gL) == 0)
{
LUA_PushUserdata(gL, player, META_PLAYER);
Rename ``seenplayer`` to ``seenfriend``
2020-01-01 18:17:29 +00:00
LUA_PushUserdata(gL, seenfriend, META_PLAYER);
**NEW!** hook_SeenPlayer
2019-12-31 17:37:45 +00:00
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
if (!lua_isnil(gL, -1) && !lua_toboolean(gL, -1))
hasSeenPlayer = false; // Hasn't seen player
lua_pop(gL, 1);
}
lua_settop(gL, 0);
hud_running = false;
return hasSeenPlayer;
}
#endif // SEENAMES
Created GameQuit hook, but I need to decide where to execute it
2020-03-12 17:22:04 +00:00
// Hook for game quitting
void LUAh_GameQuit(void)
{
hook_p hookp;
if (!gL || !(hooksAvailable[hook_GameQuit/8] & (1<<(hook_GameQuit%8))))
return;
for (hookp = roothook; hookp; hookp = hookp->next)
{
if (hookp->type != hook_GameQuit)
continue;
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
if (lua_pcall(gL, 0, 0, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
}
}
}
Rename hook to ShouldJingleContinue
2020-03-19 03:35:21 +00:00
boolean LUAh_ShouldJingleContinue(player_t *player, const char *musname)
Add JingleStatus hook for carrying custom jingle tunes The extra argument is the music name, as passed into P_PlayJingleMusic(player, musname), to run the hook for, optional. Arguments are (player, musname) - the latter to allow global hooks that still differentiate between different tracks.
2020-02-23 23:20:44 +00:00
{
hook_p hookp;
boolean keepplaying = false;
Rename hook to ShouldJingleContinue
2020-03-19 03:35:21 +00:00
if (!gL || !(hooksAvailable[hook_ShouldJingleContinue/8] & (1<<(hook_ShouldJingleContinue%8))))
Add JingleStatus hook for carrying custom jingle tunes The extra argument is the music name, as passed into P_PlayJingleMusic(player, musname), to run the hook for, optional. Arguments are (player, musname) - the latter to allow global hooks that still differentiate between different tracks.
2020-02-23 23:20:44 +00:00
return true;
lua_settop(gL, 0);
hud_running = true; // local hook
for (hookp = roothook; hookp; hookp = hookp->next)
{
Rename hook to ShouldJingleContinue
2020-03-19 03:35:21 +00:00
if (hookp->type != hook_ShouldJingleContinue
More union types for the union type god
2020-03-19 03:42:31 +00:00
|| (hookp->s.musname && strcmp(hookp->s.musname, musname)))
Add JingleStatus hook for carrying custom jingle tunes The extra argument is the music name, as passed into P_PlayJingleMusic(player, musname), to run the hook for, optional. Arguments are (player, musname) - the latter to allow global hooks that still differentiate between different tracks.
2020-02-23 23:20:44 +00:00
continue;
if (lua_gettop(gL) == 0)
{
LUA_PushUserdata(gL, player, META_PLAYER);
lua_pushstring(gL, musname);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
lua_pushvalue(gL, -3);
lua_pushvalue(gL, -3);
if (lua_pcall(gL, 2, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
hookp->error = true;
continue;
}
if (!lua_isnil(gL, -1) && lua_toboolean(gL, -1))
keepplaying = true; // Keep playing this boolean
lua_pop(gL, 1);
}
lua_settop(gL, 0);
hud_running = false;
return keepplaying;
Screw merge conflicts
2020-03-25 01:38:46 +00:00
}
Reference in a new issue Copy permalink