Upload 8 files

Cvars.txt

@@ -0,0 +1,128 @@
+CVARs
+
+This quick guide will show you what they are and how they behave.
+
+Here's a great list of cvars: http://scripting.elxdraco.net/cvarlist/
+
+What are they?
+
+You can think of them as global (sort of) variables. You can retrieve their values, set new values, and also create new cvars. They differ from actual global variables, because you can change cvar values from the console.
+
+Usage
+
+You can store all sorts of stuff in your cvars. Typically, they are used to control plugins, turn them on/off, or to hold data temporarily. You can use the flags listed below to modify the behavior of the cvars.
+
+If you will read the cvar value later on in your script, use pointers.
+
+Use get_pcvar_flags, get_pcvar_float, get_pcvar_num, or get_pcvar_string.
+Do not use get_cvar_flags, get_cvar_float, get_cvar_num, or get_cvar_string.
+
+Code:
+register_cvar ( const name[], const string[], flags = 0, Float:fvalue = 0.0 )
+
+I haven't found any examples where fvalue is used, so please post if you know what it's for.
+
+Example Usage:
+
+Code:
+new cvar_MyCvar // this is a pointer
+new cvar_OtherCvar // this is also a pointer
+
+public plugin_init()
+{
+    // this cvar has no flags assigned
+    cvar_MyCvar = register_cvar("amx_mycvar", "0")
+
+    // this cvar has two flags assigned
+    cvar_OtherCvar = register_cvar("amx_other", "1", FCVAR_SPONLY|FCVAR_UNLOGGED)
+}
+
+public MyFunction()
+{
+    if(get_pcvar_num(cvar_MyCvar))
+        return 1
+    return 0
+}
+
+How do they behave?
+
+Code:
+Order of Events:
+1.Server is off		hlds.exe is not running
+2.Server starts
+3.plugin_init()		cvars are created
+4.plugin_cfg()
+5.amxx.cfg		cvars assigned values from amxx.cfg
+6.server.cfg		cvars assigned values from server.cfg
+7.Server restarts	mapchange or 'restart' command
+8.plugin_init()		cvars are NOT re-created or overwritten; if they exist, only pointers are gathered
+9.plugin_cfg()
+10.amxx.cfg		cvars assigned values from amxx.cfg (server.cfg is not called next)
+The functions plugin_init() and plugin_cfg() are called on every map-change, restart, and "fresh" start. ("Fresh" start means the server turned on after being off.) The amxx.cfg file is read on every map-change, restart and "fresh" start. The server.cfg file is only read on "fresh" starts.
+
+When you do register_cvar("cvar_name", "cvar_value"), you are attempting to create a new cvar with a new default value. If this cvar already exists, this function will not overwrite the original value. Instead, it will return a pointer to the existing cvar that you can later access with get_pcvar_flags, get_pcvar_float, get_pcvar_num, or get_pcvar_string.
+
+To get a pointer for a cvar, use get_cvar_pointer("cvarname").
+
+CVAR flags
+
+This is taken directly from amxconst.inc:
+FCVAR_ARCHIVE set to cause it to be saved to vars.rc
+FCVAR_USERINFO changes the client's info string
+FCVAR_SERVER notifies players when changed
+FCVAR_EXTDLL defined by external DLL
+FCVAR_CLIENTDLL defined by the client dll
+FCVAR_PROTECTED It's a server cvar, but we don't send the data since it's a password, etc. Sends 1 if it's not bland/zero, 0 otherwise as value
+FCVAR_SPONLY This cvar cannot be changed by clients connected to a multiplayer server.
+FCVAR_PRINTABLEONLY This cvar's string cannot contain unprintable characters ( e.g., used for player name etc ).
+FCVAR_UNLOGGED If this is a FCVAR_SERVER, don't log changes to the log file / console if we are creating a log
+
+Unfortunately, I can't find any examples for the following flags: FCVAR_ARCHIVE, FCVAR_USERINFO, FCVAR_EXTDLL, FCVAR_CLIENTDLL.
+
+So, I'd like to ask anyone who knows about these flags to post.
+
+Example
+
+Here's a simple script that counts how many times a server stops running. If you can understand how this script works, then you probably have a good grip on cvars.
+
+This script should only be used as a demonstration to understand cvars. If you really want to count crashes accurately, I would recommend a different method. Let me know if you're interested.
+
+Code:
+#include <amxmodx>
+
+#define PLUGIN "Crash Counter"
+#define VERSION "1.0"
+#define AUTHOR "stupok"
+
+#define DIR_CRASHLOG    "addons\amxmodx\logs\CrashLog"
+#define FILE_CRASHMAP   "addons\amxmodx\logs\CrashLog\crash_map.txt"
+#define FILE_LOG    "CrashLog.log" // will be found in addons\amxmodx\logs
+
+new cvar_Crashed
+
+public plugin_init()
+{
+    register_plugin(PLUGIN, VERSION, AUTHOR)
+    
+    cvar_Crashed = register_cvar("server_crashed", "1", FCVAR_SPONLY) // do not let players edit this cvar
+    
+    if(!dir_exists(DIR_CRASHLOG)) mkdir(DIR_CRASHLOG) // make addons\amxmodx\logs\CrashLog
+    
+    if(!file_exists(FILE_CRASHMAP)) write_file(FILE_CRASHMAP, "-- Do not edit --", -1) // make crash_map.txt
+    
+    new szMapName[32]
+    new iLineLen
+    read_file(FILE_CRASHMAP, 2, szMapName, charsmax(szMapName), iLineLen) // read previous map from file
+    
+    if(get_pcvar_num(cvar_Crashed)) // check if server just started, 1 = start, 0 = restart/mapchange
+    {
+        if(szMapName[0]) // do we have a map from crash_map.txt?
+        {
+            log_to_file(FILE_LOG, "The server exited or crashed on '%s' before this recorded time.", szMapName)
+        }
+        set_pcvar_num(cvar_Crashed, 0) // this will be set to 1 again when the server has a "fresh" start (not restart)
+    }
+    
+    get_mapname(szMapName, charsmax(szMapName)) // get the name of the current map
+    write_file(FILE_CRASHMAP, szMapName, 2) // write it to crash_map.txt
+}

Dynamic, Fake Natives.txt

@@ -0,0 +1,105 @@
+Dynamic / Fake Natives (I will refer to them as dynamic from here onward, I don't like the word fake when they actually do something) allow you to have the functionality of a module (through natives) by having a plugin that acts like a module running. In theory, it is possible to port entire modules to fakemeta + plugins using this principle (fun has already been done, engine can be done with more difficulty). From my experiences, dynamic natives go hand and hand with API design as shown in my "Plugin API" tutorial.
+
+Here are the natives that are used along for dynamic natives:
+register_native
+register_library
+get_param
+get_param_byref
+get_param_f
+get_string
+get_array
+get_array_f
+set_array
+set_array_f
+set_string
+param_convert
+
+Please keep in mind that dynamic natives are pretty useless when not dealing with more than one plugin. As such, the following examples will always be at least 2 scripts, plus one include file.
+
+Here is a simple example to show the basics of dynamic natives:
+
+Code:
+#include <amxmodx>
+#include <fun>
+
+public plugin_init()
+    register_plugin("Dynamic Native Test - Handler","1.0","Hawk552")
+    
+public plugin_natives()
+{
+    register_library("dyn_test")
+    
+    register_native("half_user_hp","_half_user_hp")
+}
+
+public _half_user_hp(iPlugin,iParams)
+{
+    if(iParams != 1)
+        return PLUGIN_CONTINUE
+        
+    new id = get_param(1)
+    if(!id)
+        return PLUGIN_CONTINUE
+        
+    set_user_health(id,get_user_health(id) / 2)
+    
+    return PLUGIN_HANDLED
+}
+
+Code:
+#include <amxmodx>
+#include <dyn_test>
+
+public plugin_init()
+    register_plugin("Dynamic Native Test - Caller","1.0","Hawk552")
+    
+public client_putinserver(id)
+    if(is_user_alive(id))
+        half_user_hp(id)
+
+Code:
+// NOTE: This file MUST be called dyn_test.inc (or you have to rename the #include <dyn_test> in script 2)
+
+#pragma reqlib "dyn_test"
+
+native half_user_hp(id)
+
+Now, what is this doing? Basically, on client_putinserver, if the user is alive (which is only true in mods like sven coop where you spawn right away) then it will slice their HP in half. Let's pick apart each thing.
+
+Script 1
+
+At first we look at the plugin_init, and we notice nothing special. We then look down and see "plugin_natives", a forward most people here have probably never seen before. This is where natives and libraries must be registered. DO NOT try to put them in other forwards, like plugin_init or plugin_precache.
+
+Now, let's look at the first part of plugin_natives, which is register_library.
+
+What does this do? It basically tells AMXX that this plugin provides native functionality to other plugins, and aids with "native not found" errors to check if the plugin is loaded before trying to call the dynamic native. In this case, we're calling our library "dyn_test" for "Dynamic Native Test". There are 2 types of libraries in AMXX core, as of 1.75: libraries and classes. A module is a library, while a plugin is a class. This information is useful for LibraryExists, which will be covered later.
+
+Next, we see register_native.
+
+const native[] - this is the name of the native to register. Pretty obvious.
+const handler[] - this is the name of the function that will be called when this native is used. Remember, it must be public (as with almost all functions that are put in quotes or called by outside sources)
+[ style = 0 ] - this is will be covered later
+
+Now, as we look at the register_native call, we see the handler is _half_user_hp. So, we look down, and we see this function.
+
+Code:
+public _half_user_hp(iPlugin,iParams)
+
+In all dynamic natives, unless registered with style=1, we see something to the effect of (id,params), which I decided to rename in the header. The first param is the plugin id - this is useful in case you want to send it back a callfunc or a CreateOneForward/ExecuteForward, or have an array that stores data for each plugin loaded. The next param is iParams. In the case of the above example, iParams must be 1, because the only param is 1. If it's anything different, someone decided to be stupid and modify the include file.
+
+Next, inside the function we check if iParams == 1, and if it doesn't we stop there. Next, we get_param(1), which allows you to get the first parameter assuming it's a cell (which it is). We then check if id is a counting number, because we can't use 0 with get_user_health. The rest is pretty self explanatory.
+
+In this example, I returned PLUGIN_CONTINUE because that evaluates to false, and PLUGIN_HANDLED because it evaluates to true. This allows you to do simple error checking, ie "if(!half_user_health(id)) log_amx("failed")".
+
+Now that the handler is out of the way, we get down to the plugin that will use this dynamic native.
+
+First, I'd like you to look at the include file (the 3rd example). The first thing we see is #pragma reqlib "dyn_test". This effectively tells AMXX "If dyn_test isn't loaded, error me right here." The register_library function in the first example is what lets you bypass this, because it tells AMXX that dyn_test does exist. Next, in this same file, we see native half_user_hp(id). This basically tells the compiler that half_user_hp will be handled in the VM layer (which is where all the C++ coding is), but the VM layer will pass it down to the function that handles the dynamic native. After it's handled, the VM layer will pass the result back to the calling function.
+
+Onto the script itself, we see that we included this file through #include <dyn_test>. The rest is quite self explanatory.
+
+As for the get_param section, the natives above (get_param_f, get_param_byref, etc.) can be used to replace this, depending upon what arguments are passed into the function.
+
+Now, onto style = 1. This style basically forgets about the iPlugin,iParams part of the header, and then assumes the plugin will pass the parameters correctly. This means _half_user_hp would look like:
+
+Code:
+public _half_user_hp(id)

EngFunc Tutorial.txt

@@ -0,0 +1,318 @@
+#include <amxmodx>
+#include <amxmisc>
+#include <fakemeta>
+#include <fakemeta_util>
+#include <xs>
+
+#pragma semicolon 1
+
+#define PLUGIN_NAME "Tutorial Plugin"
+#define PLUGIN_VERSION "1.0"
+#define PLUGIN_AUTHOR "JoRoPiTo"
+
+#define STR 32
+#define LOG 128
+
+#define TUT_PREFIX "[AMXX TUT]"
+#define DIVISOR "======================================================="
+
+static g_beamSprite;
+static g_maxEntities;
+static g_maxClients;
+static g_msgSayText;
+
+
+public plugin_init()
+{
+	register_plugin(PLUGIN_NAME, PLUGIN_VERSION, PLUGIN_AUTHOR);
+
+	// Console commands
+	register_concmd("con_showents", "con_showents");
+
+	// Client commands
+	register_clcmd("tutorial1", "tut_FindEntityByString");
+	register_clcmd("tutorial2", "tut_FindEntityInSphere");
+	register_clcmd("tutorial3", "tut_FindClientInPVS");
+	register_clcmd("tutorial4", "tut_TraceLine");
+	register_clcmd("tutorial5", "tut_TraceModel");
+
+	g_maxEntities = global_get(glb_maxEntities);
+	g_maxClients = global_get(glb_maxClients);
+	g_msgSayText = get_user_msgid("SayText");
+}
+
+public plugin_precache()
+{
+	g_beamSprite = precache_model("sprites/zbeam1.spr");
+}
+
+
+//------------------------------------------------------------------------
+//Internal functions
+//------------------------------------------------------------------------
+stock fn_log_con(name[], msg[])
+{
+	server_print("%s %s: %s", TUT_PREFIX, name, msg);
+}
+
+stock fn_log_cli(id, name[], msg[])
+{
+	static text[LOG];
+	formatex(text, charsmax(text), "^x04%s %s:^x01 %s", TUT_PREFIX, name, msg);
+	if(id != 0)
+	{
+		message_begin(MSG_ONE, g_msgSayText, {0,0,0}, id);
+		write_byte(id);
+		write_string(text);
+		message_end();
+	}
+	else
+	{
+		client_print(0, print_chat, text);
+	}
+}
+
+stock fn_create_beam(Float:origin[3], Float:end[3], t, r, g, b)
+{
+        message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
+        write_byte(TE_BEAMPOINTS);
+	engfunc(EngFunc_WriteCoord, origin[0]);
+	engfunc(EngFunc_WriteCoord, origin[1]);
+	engfunc(EngFunc_WriteCoord, origin[2]);
+	engfunc(EngFunc_WriteCoord, end[0]);
+	engfunc(EngFunc_WriteCoord, end[1]);
+	engfunc(EngFunc_WriteCoord, end[2]);
+        write_short(g_beamSprite);
+	write_byte(1);
+	write_byte(5);
+	write_byte(t);
+	write_byte(20);
+	write_byte(0);
+	write_byte(r);
+	write_byte(g);
+	write_byte(b);
+	write_byte(200);
+	write_byte(200);
+        message_end();
+}
+
+//------------------------------------------------------------------------
+//Console functions
+//------------------------------------------------------------------------
+
+public con_showents()
+{
+	new class[STR], str[LOG];
+	new origin[3];
+	new ent, owner;
+	for(ent=1; ent < g_maxEntities; ++ent)
+	{
+		if(!pev_valid(ent))
+			continue;
+
+		pev(ent, pev_origin, origin);
+		pev(ent, pev_classname, class, charsmax(class));
+		owner = pev(ent, pev_owner);
+		formatex(str, charsmax(str), "%i %s (owner:%i) (%f,%f,%f)", ent, class, owner, origin[0], origin[1], origin[2]);
+		fn_log_con("Entity", str);
+	}
+	return PLUGIN_HANDLED;
+}
+
+//------------------------------------------------------------------------
+//Client functions
+//------------------------------------------------------------------------
+
+// FindEntityByString
+// This tutorial makes lines from the player to every player in the map
+public tut_FindEntityByString(id)
+{
+	static Float:origin[3];
+	static Float:point[3];
+	static text[LOG];
+	static ent;
+	static const class[] = "player";	// We are going to find "player" entitities
+
+	pev(id, pev_origin, origin);
+	pev(id, pev_view_ofs, point); 
+	xs_vec_add(origin, point, origin);
+
+	fn_log_cli(id, "FindEntityInSphere", DIVISOR);
+	ent = -1;
+	while((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", class)))
+	{
+		// We don't want our own entity
+		if(ent == id)
+			continue;
+
+		if(!pev_valid(ent))
+			continue;
+
+		pev(ent, pev_origin, point);
+		fn_create_beam(origin, point, 60, 255, 0, 0);	// Create red line from ID to ENT for 60 seconds
+		formatex(text, charsmax(text), "Found entity 'player' (ent:%i)", ent);
+		fn_log_cli(id, "FindEntityInSphere", text);
+	}
+
+	return PLUGIN_HANDLED;
+}
+
+// FindEntityInSphere
+// This tutorial makes lines from a player to every entity found in sphere radius
+public tut_FindEntityInSphere(id)
+{
+	static Float:origin[3];
+	static Float:point[3];
+	static text[LOG];
+	static class[STR];
+	static ent;
+	static const radius = 2000;	// We are going to find entities using this sphere radius
+
+	pev(id, pev_origin, origin);
+	pev(id, pev_view_ofs, point); 
+	xs_vec_add(origin, point, origin);
+
+	fn_log_cli(id, "FindEntityInSphere", DIVISOR);
+	ent = -1;
+	while((ent = engfunc(EngFunc_FindEntityInSphere, ent, origin, radius)))
+	{
+		// We don't want worldspawn entity
+		if(ent == 0)
+			continue;
+
+		// We don't want our own entity
+		if(ent == id)
+			continue;
+
+		if(!pev_valid(ent))
+			continue;
+
+		pev(ent, pev_origin, point);
+		pev(ent, pev_classname, class, charsmax(class));
+		if(equal(class, "func_buyzone") || equal(class, "player") || equal(class, "func_bomb_target")
+			|| equal(class, "func_breakable") || equal(class, "func_door"))
+		{
+			fn_create_beam(origin, point, 60, 0, 255, 0);	// Create green line from ID to ENT for 60 seconds
+			formatex(text, charsmax(text), "Found entity in sphere (ent:%i class:%s)", ent, class);
+			fn_log_cli(id, "FindEntityInSphere", text);
+		}
+	}
+	return PLUGIN_HANDLED;
+}
+
+// FindClientInPVS
+// This tutorial makes lines from a player to every entity found in PVS
+public tut_FindClientInPVS(id)
+{
+	static Float:origin[3];
+	static Float:point[3];
+	static class[STR];
+	static text[LOG];
+	static ent, chain;
+
+	pev(id, pev_origin, origin);
+	pev(id, pev_view_ofs, point); 
+	xs_vec_add(origin, point, origin);
+
+	fn_log_cli(id, "FindClientInPVS", DIVISOR);
+
+	ent = engfunc(EngFunc_EntitiesInPVS, id);
+	while(ent)
+	{
+		chain = pev(ent, pev_chain);
+		pev(ent, pev_origin, point);
+		pev(ent, pev_classname, class, charsmax(class));
+		if(!equal(class, ""))
+		{
+			fn_create_beam(origin, point, 60, 0, 0, 255);	// Create blue line from ID to ENT for 60 seconds
+			formatex(text, charsmax(text), "Found entity in PVS (ent:%i class:%s)", ent, class);
+			fn_log_con("FindClientInPVS", text);
+		}
+
+		if(!chain)
+			break;
+
+		ent = chain;
+	}
+	return PLUGIN_HANDLED;
+}
+
+// TraceLine
+// This tutorial makes 2 lines, one of them stoping on entities.
+public tut_TraceLine(id)
+{
+	static Float:origin[3];
+	static Float:aim[3];
+	static Float:point[3];
+	static text[LOG];
+	static const tr = 0;
+
+	pev(id, pev_origin, origin);
+	pev(id, pev_view_ofs, aim); 
+	xs_vec_add(origin, aim, origin);
+
+	fm_get_aim_origin(id, aim);
+	// Multiply vector to make it larger
+	xs_vec_sub(aim, origin, aim);
+	xs_vec_mul_scalar(aim, 10.0, aim);
+	xs_vec_add(origin, aim, aim);
+
+	engfunc(EngFunc_TraceLine, origin, aim, 0, id, tr);
+
+	fn_log_cli(id, "TraceLine", DIVISOR);
+	fn_create_beam(origin, aim, 60, 255, 0, 0);	// Create red line from ID to aim point for 60 seconds
+	formatex(text, charsmax(text), "Created red line to aim point");
+	fn_log_cli(id, "TraceLine", text);
+
+	get_tr2(tr, TR_vecEndPos, point);
+	fn_create_beam(origin, point, 60, 0, 255, 0);	// Create green line from ID to hit point for 60 seconds
+	formatex(text, charsmax(text), "Created green line to hit point");
+	fn_log_cli(id, "TraceLine", text);
+
+	return PLUGIN_HANDLED;
+}
+
+// TraceModel
+// This tutorial makes one line to where you are aiming. The color of the line depends on the model you hit.
+public tut_TraceModel(id)
+{
+	static Float:origin[3];
+	static Float:aim[3];
+	static Float:point[3];
+	static class[STR];
+	static text[LOG];
+	static ent;
+	static const tr = 0;
+
+	pev(id, pev_origin, origin);
+	pev(id, pev_view_ofs, aim); 
+	xs_vec_add(origin, aim, origin);
+
+	fm_get_aim_origin(id, aim);
+	// Multiply vector to make it larger
+	xs_vec_sub(aim, origin, aim);
+	xs_vec_mul_scalar(aim, 2.0, aim);
+
+	for(ent=g_maxClients+1; ent<g_maxEntities; ent++)
+	{
+		if(!pev_valid(ent))
+			continue;
+
+		pev(ent, pev_classname, class, charsmax(class));
+		if(equal(class, "weaponbox") || equal(class, "armoury_entity") || equal(class, "player")
+			|| equal(class, "func_breakable") || equal(class, "func_door"))
+		{
+			engfunc(EngFunc_TraceModel, origin, aim, HULL_POINT, ent, tr);
+			if((ent > 0) && (get_tr2(tr, TR_pHit) == ent))
+			{
+				fn_log_cli(id, "TraceModel", DIVISOR);
+				formatex(text, charsmax(text), "Found model by aim (ent:%i class:%s)", ent, class);
+				fn_log_cli(id, "TraceModel", text);
+				get_tr2(tr, TR_vecEndPos, point);
+				fn_create_beam(origin, point, 60, 0, 255, 0);	// Create green line from ID to hit point for 60 seconds
+			}
+		}
+	}
+
+	return PLUGIN_HANDLED;
+}

Fakemeta General.txt

@@ -0,0 +1,104 @@
+About
+
+FakeMeta is an extremely powerful module for AMX Mod X that effectively allows you to write Metamod plugins in Pawn.
+Unlike Engine, FakeMeta uses no CPU if it is not told to do anything (other than to exist). For this reason, it is recommended to use FakeMeta over Engine. There is nothing in Engine that is not in FakeMeta -- while some functionality might be less abstracted, it is still achievable, and usually with more flexibility.
+
+
+Engine vs. FakeMeta
+
+Comparison between Engine and FakeMeta:
+FakeMeta:
+Code:
+#include <amxmodx>
+#include <fakemeta>
+ 
+public plugin_init()
+{
+    register_plugin("FakeMeta Test","1.0","Hawk552");
+    
+    register_forward(FM_PlayerPreThink,"PreThink");
+}
+ 
+public PreThink(id)
+{
+    // here you would insert some code
+    
+    return FMRES_IGNORED;
+}
+Engine:
+Code:
+#include <amxmodx>
+#include <engine>
+ 
+public plugin_init()
+{
+    register_plugin("FakeMeta Test","1.0","Hawk552");
+}
+ 
+public client_PreThink(id)
+{
+    // here you would insert some code
+    
+    return;
+}
+The "return FMRES_IGNORED" section will be covered later on this page.
+
+
+General Functionality
+
+FakeMeta also allows you to do other things, such as retrieve private data (using pev, set_pev / get_pdata_int, get_pdata_float, get_pdata_string, set_pdata_int, set_pdata_float, set_pdata_string), forcing DLL functions to be executed, as well as call Engine (not the module) functions.
+
+
+Entvars
+
+It is easy to read entvars in FakeMeta, however it can sometimes cause problems if not done correctly (which is why Engine is more commonly used). Entvars are variables in a player's edict structure (an edict is the basis for an entity).
+Here is an example of how to retrieve the armor entvar from an entity in FakeMeta:
+Code:
+#include <amxmodx>
+#include <fakemeta>
+ 
+public plugin_init()
+{
+    register_plugin("FakeMeta Test","1.0","Hawk552");
+    
+    register_forward(FM_PlayerPreThink, "PreThink");
+}
+ 
+public PreThink(id)
+{
+    new value = pev(id,pev_armorvalue); // gets armor from client/entity
+    
+    client_print(id,print_chat,"%i",value); // prints armor value to client
+    
+    return FMRES_IGNORED;
+}
+DLL / Engine Function Usage
+
+In DLLs and the Engine, there are functions that are called when certain events happen. These can be forced to be called through FakeMeta. Here is a general example:
+Code:
+#include <amxmodx>
+#include <fakemeta>
+ 
+public plugin_init()
+{
+    register_plugin("FakeMeta Test","1.0","Hawk552");
+    
+    register_forward(FM_PlayerPreThink,"PreThink");
+}
+ 
+public PreThink(id)
+{
+    dllfunc(DLLFunc_RegisterEncoders);
+    
+    return FMRES_IGNORED;
+}
+Refer to the end of the line while viewing the DLLFunc and EngFunc sections, as there is usually some description of paramaters, such as edict_t *p_Entity or void. void generally refers to no parameters, while edict_t *p_Entity means the entity id, so the first parameter in the function would be the entity to call the function onto.
+
+
+Return Values
+
+There are 4 return values in FakeMeta:
+FMRES_HANDLED --> Something was done in this function, but call the one in the DLL / Engine anyways.
+FMRES_SUPERCEDE --> Prevent function in DLL / Engine from being called.
+FMRES_IGNORED --> Call original function.
+FMRES_OVERRIDE --

Issues, Examples.txt

@@ -0,0 +1,321 @@
+This is a compilation of examples, explanations, and answers for commonly asked questions / issues.
+
+The Countdown
+Code:
+#include <amxmodx>
+
+#define TASKID  1996
+#define SECONDS 10
+
+new iSeconds
+
+public plugin_init()
+{
+    register_plugin( "Countdown Example", "1.0", "Wrecked" )
+    
+    register_logevent( "LogEventRoundStart", 2, "1=Round_Start" )
+}
+
+public LogEventRoundStart()
+{
+    if( task_exists( TASKID ) )
+        remove_task( TASKID )
+        
+    iSeconds = SECONDS
+    set_task( 1.0, "TaskShowCountdown", TASKID, _, _, "a", SECONDS )
+}
+
+public TaskShowCountdown()
+{
+    set_hudmessage( 120, 120, 120, 0.50, 0.50, 0, 0.1, 0.8, 0.1, 0.1, -1 )
+    show_hudmessage( 0, "Seconds Remaining: %i", iSeconds-- )
+}
+Detecting Kill/Headshot Streaks
+
+Code:
+#include <amxmodx>
+
+new Headshots[33]
+new Kills[33]
+
+public plugin_init()
+{
+    register_plugin( "How To Keep Kill Counts", "1.0", "Wrecked" )
+    
+    register_event( "DeathMsg", "EventDeathMsg", "a" )
+    
+    register_logevent( "LogEventRoundStart", 2, "1=Round_Start" )
+}
+
+public EventDeathMsg()
+{
+    new killer = read_data( 1 )
+    new victim = read_data( 2 )
+    
+    Headshots[victim] = 0
+    Kills[victim] = 0
+    Kills[killer]++
+    
+    if( read_data( 3 ) ) // headshot
+        Headshots[killer]++
+        
+    // Kills holds kills of each player
+    // Headshots holds headshots
+}
+
+public LogEventRoundStart()
+{
+    arrayset( Headshots, 0, 33 )
+    arrayset( Kills, 0, 33 )
+}
+Once Every x Rounds
+
+Code:
+#include <amxmodx>
+
+#define ROUND_INTERVAL  4
+
+new iRound
+
+public plugin_init()
+{
+    register_plugin( "Do Something Every X Rounds", "1.0", "Wrecked" )
+    
+    register_logevent( "LogEventRoundStart", 2, "1=Round_Start" )
+}
+
+public LogEventRoundStart()
+{
+    if( ( ++iRound % ROUND_INTERVAL ) == 1 )
+        // do whatever you need to do here
+}
+
+Blocking Weapon Pickup
+Code:
+#include <amxmodx>
+#include <hamsandwich>
+
+public plugin_init()
+{
+    register_plugin( "Block Weapon Pickup", "1.0", "Wrecked" )
+    
+    new classname[20] // weapon_smokegrenade (19) + 1
+    
+    for( new i = CSW_P228; i <= CSW_P90; i++ )
+    {
+        if ( get_weaponname( i, classname, charsmax( classname ) ) )
+        {
+            RegisterHam( Ham_Item_Deploy, classname, "HamItemDeployPre", 0 )
+            /* Other forwards that you could've used:
+                * Ham_AddPlayerItem
+                * Ham_Item_CanDeploy
+            */
+        }
+    }
+}
+
+public HamItemDeployPre( weapon )
+{
+    return HAM_SUPERCEDE; // blocks function call
+}
+
+Properly Removing Buyzones (by Exolent[jNr])
+Code:
+#include < amxmodx >
+#include < engine >
+#include < fakemeta >
+
+new const info_map_parameters[ ] = "info_map_parameters";
+
+new g_hSpawn;
+
+public plugin_precache( ) {
+    new iEntity = create_entity( info_map_parameters );
+    DispatchKeyValue( iEntity, "buying", "3" );
+    DispatchSpawn( iEntity );
+    
+    g_hSpawn = register_forward( FM_Spawn, "FwdSpawn" );
+}
+
+public FwdSpawn( iEntity ) {
+    static szClassname[ 32 ];
+    entity_get_string( iEntity, EV_SZ_classname, szClassname, 31 );
+    
+    if( equal( szClassname, info_map_parameters ) ) {
+        remove_entity( iEntity );
+        
+        return FMRES_SUPERCEDE;
+    }
+    
+    return FMRES_IGNORED;
+}
+
+public plugin_init( ) {
+    if( g_hSpawn > 0 ) {
+        unregister_forward( FM_Spawn, g_hSpawn );
+    }
+}
+
+Properly Removing an Entity at Plugin Start (by Alucard^)
+Code:
+#include <amxmodx>
+#include <fakemeta>
+
+new const g_RemoveEntity[] = "classname_here";
+
+public plugin_precache()
+{
+    register_plugin("Fine", "and", "you?");
+    
+    // Remember to do this in plugin_precache, if you
+    // do this in plugin_init( ) this will not work!
+    
+    register_forward(FM_Spawn, "HookFmSpawn");
+}
+
+public HookFmSpawn(iEntity)
+{
+    if(!pev_valid(iEntity) )
+        return FMRES_IGNORED;
+    
+    static szClassName[32];
+    pev(iEntity, pev_classname, szClassName, 31);
+    
+    if(equali(szClassName, g_RemoveEntity) )
+    {
+        engfunc(EngFunc_RemoveEntity, iEntity);
+
+        return FMRES_SUPERCEDE;
+    }
+    
+    return FMRES_IGNORED;
+}
+
+What is the proper way to respawn someone?
+Well, there are two methods that are correct and efficient.
+Code:
+// GOOD, hamsandwich
+ExecuteHamB( Ham_CS_RoundRespawn, playerindex )
+
+// GOOD, fakemeta
+set_pev( playerindex, pev_deadflag, DEAD_RESPAWNABLE )
+
+// BAD, fun
+// This is usable, but requires a fix that really isn't worth it.
+spawn( playerindex )
+
+// BAD, cstrike
+cs_user_spawn( playerindex )
+
+What module should I use for my large plugin? Fakemeta or engine?
+You should use whatever module gets the job done. The actual efficiency impact between including either is very trivial. Don't be hesitant to include both if you need both to get what you need done properly.
+
+I've compiled my plugin and the loose indentation warning has come up. What is this and how can I fix it?
+This warning shows up whenever you indent your lines with spaces AND tabs. Conform to using one style; I personally use tabs because they're much easier.
+
+How do I dynamically add values into my menu title / items?
+Code:
+menufunc()
+{
+    new info[128]
+    formatex( info, 127, "Welcome to the Point Shop^nYour Points: %i", iVariableForPoints[id] )
+    new menu = menu_create( info, "HandlerFunction" )
+    
+    // rest of menu code
+}
+
+How to remove properly the BuyZones in the map:
+
+Code:
+#include <amxmodx>
+#include <fakemeta>
+
+public plugin_precache()
+{
+    register_plugin("How", "are", "you?");
+
+    // If i am not wrong, this must be made in plugin_precache( )
+    
+    new iEnt;
+    
+    iEnt = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_map_parameters") );
+    SetKeyValue(iEnt, "buying", "3", "info_map_parameters");
+    dllfunc(DLLFunc_KeyValue, iEnt, 0);
+}
+
+SetKeyValue(iEnt, const szKey[], const szValue[], const szClassName[])
+{
+    set_kvd(0, KV_ClassName, szClassName);
+    set_kvd(0, KV_KeyName, szKey);
+    set_kvd(0, KV_Value, szValue);
+    set_kvd(0, KV_fHandled, 0);
+    
+    dllfunc(DLLFunc_KeyValue, iEnt, 0);
+}
+
+How to remove properly an entity in the map:
+
+Code:
+#include <amxmodx>
+#include <fakemeta>
+
+new const g_RemoveEntity[] = "func_push";
+
+public plugin_precache()
+{
+    register_plugin("Fine", "and", "you?");
+    
+    // Remember to do this in plugin_precache, if you
+    // do this in plugin_init( ) this will not work!
+    
+    register_forward(FM_Spawn, "HookFmSpawn", 1);
+}
+
+public HookFmSpawn(iEntity)
+{
+    if(!pev_valid(iEntity) )
+        return FMRES_IGNORED;
+    
+    new szClassName[32];
+    pev(iEntity, pev_classname, szClassName, 31);
+    
+    if(equali(szClassName, g_RemoveEntity) )
+    {
+        engfunc(EngFunc_RemoveEntity, iEntity);
+        return FMRES_SUPERCEDE;
+    }
+    
+    return FMRES_IGNORED;
+}
+
+This is really simple but, for some people that want to do something at the first spawn only, or at the first event (round start, or whatever):
+
+Code:
+#include <amxmodx>
+#include <hamsandwich>
+
+#define PLUGIN  "First Spawn"
+#define AUTHOR  "Alucard"
+#define VERSION "0.0.1"
+
+new bool:FirstSpawn[33];
+
+public plugin_init()
+{
+    register_plugin(PLUGIN, VERSION, AUTHOR);
+    RegisterHam(Ham_Spawn, "player", "HookPlrSpawn", 1);
+}
+
+public client_connect(id)
+    FirstSpawn[id] = true;
+
+public HookPlrSpawn(id)
+{
+    if(FirstSpawn[id])
+    {
+        // do stuff here, that you only want
+        // to do at the first spawn
+        
+        FirstSpawn[id] = false;
+    }
+}

fakemeta_util.inc.txt

@@ -0,0 +1,831 @@
+/* Fakemeta Utilities
+*
+* by VEN
+*
+* This file is provided as is (no warranties).
+*/
+
+#if !defined _fakemeta_included
+	#include <fakemeta>
+#endif
+
+#if defined _fakemeta_util_included
+	#endinput
+#endif
+#define _fakemeta_util_included
+
+#include <xs>
+#include <hlsdk_const> //! this line should be removed for 1.75
+
+
+/* Engine functions */
+
+#define fm_precache_generic(%1) engfunc(EngFunc_PrecacheGeneric, %1)
+/* stock fm_precache_generic(const file[])
+	return engfunc(EngFunc_PrecacheGeneric, file) */
+
+#define fm_precache_event(%1,%2) engfunc(EngFunc_PrecacheEvent, %1, %2)
+/* stock fm_precache_event(type, const name[])
+	return engfunc(EngFunc_PrecacheEvent, type, name) */
+
+// ported by v3x
+#define fm_drop_to_floor(%1) engfunc(EngFunc_DropToFloor, %1)
+/* stock fm_drop_to_floor(entity)
+	return engfunc(EngFunc_DropToFloor, entity) */
+
+#define fm_force_use(%1,%2) dllfunc(DLLFunc_Use, %2, %1)
+/* stock fm_force_use(user, used)
+	return dllfunc(DLLFunc_Use, used, user) */
+
+#define fm_entity_set_size(%1,%2,%3) engfunc(EngFunc_SetSize, %1, %2, %3)
+/* stock fm_entity_set_size(index, const Float:mins[3], const Float:maxs[3])
+	return engfunc(EngFunc_SetSize, index, mins, maxs) */
+
+#define fm_get_decal_index(%1) engfunc(EngFunc_DecalIndex, %1)
+/* stock fm_get_decal_index(const decalname[])
+	return engfunc(EngFunc_DecalIndex, decalname) */
+
+stock Float:fm_entity_range(ent1, ent2) {
+	new Float:origin1[3], Float:origin2[3]
+	pev(ent1, pev_origin, origin1)
+	pev(ent2, pev_origin, origin2)
+
+	return get_distance_f(origin1, origin2)
+}
+
+// based on KoST's port, upgraded version fits into the macros
+#define fm_create_entity(%1) engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, %1))
+/* stock fm_create_entity(const classname[])
+	return engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, classname)) */
+
+#define fm_find_ent_by_class(%1,%2) engfunc(EngFunc_FindEntityByString, %1, "classname", %2)
+/* stock fm_find_ent_by_class(index, const classname[])
+	return engfunc(EngFunc_FindEntityByString, index, "classname", classname) */
+
+stock fm_find_ent_by_owner(index, const classname[], owner, jghgtype = 0) {
+	new strtype[11] = "classname", ent = index
+	switch (jghgtype) {
+		case 1: copy(strtype, 6, "target")
+		case 2: copy(strtype, 10, "targetname")
+	}
+
+	while ((ent = engfunc(EngFunc_FindEntityByString, ent, strtype, classname)) && pev(ent, pev_owner) != owner) {}
+
+	return ent
+}
+
+#define fm_find_ent_by_target(%1,%2) engfunc(EngFunc_FindEntityByString, %1, "target", %2)
+/* stock fm_find_ent_by_target(index, const target[])
+	return engfunc(EngFunc_FindEntityByString, index, "target", target) */
+
+#define fm_find_ent_by_tname(%1,%2) engfunc(EngFunc_FindEntityByString, %1, "targetname", %2)
+/* stock fm_find_ent_by_tname(index, const targetname[])
+	return engfunc(EngFunc_FindEntityByString, index, "targetname", targetname) */
+
+stock fm_find_ent_by_model(index, const classname[], const model[]) {
+	new ent = index, mdl[72]
+	while ((ent = fm_find_ent_by_class(ent, classname))) {
+		pev(ent, pev_model, mdl, 71)
+		if (equal(mdl, model))
+			return ent
+	}
+
+	return 0
+}
+
+#define fm_find_ent_in_sphere(%1,%2,%3) engfunc(EngFunc_FindEntityInSphere, %1, %2, %3)
+/* stock fm_find_ent_in_sphere(index, const Float:origin[3], Float:radius)
+	return engfunc(EngFunc_FindEntityInSphere, index, origin, radius) */
+
+#define fm_call_think(%1) dllfunc(DLLFunc_Think, %1)
+/* stock fm_call_think(entity)
+	return dllfunc(DLLFunc_Think, entity) */
+
+#define fm_is_valid_ent(%1) pev_valid(%1)
+/* stock fm_is_valid_ent(index)
+	return pev_valid(index) */
+
+stock fm_entity_set_origin(index, const Float:origin[3]) {
+	new Float:mins[3], Float:maxs[3]
+	pev(index, pev_mins, mins)
+	pev(index, pev_maxs, maxs)
+	engfunc(EngFunc_SetSize, index, mins, maxs)
+
+	return engfunc(EngFunc_SetOrigin, index, origin)
+}
+
+#define fm_entity_set_model(%1,%2) engfunc(EngFunc_SetModel, %1, %2)
+/* stock fm_entity_set_model(index, const model[])
+	return engfunc(EngFunc_SetModel, index, model) */
+
+// ported by v3x
+#define fm_remove_entity(%1) engfunc(EngFunc_RemoveEntity, %1)
+/* stock fm_remove_entity(index)
+	return engfunc(EngFunc_RemoveEntity, index) */
+
+#define fm_entity_count() engfunc(EngFunc_NumberOfEntities)
+/* stock fm_entity_count()
+	return engfunc(EngFunc_NumberOfEntities) */
+
+#define fm_fake_touch(%1,%2) dllfunc(DLLFunc_Touch, %1, %2)
+/* stock fm_fake_touch(toucher, touched)
+	return dllfunc(DLLFunc_Touch, toucher, touched) */
+
+#define fm_DispatchSpawn(%1) dllfunc(DLLFunc_Spawn, %1)
+/* stock fm_DispatchSpawn(entity)
+	return dllfunc(DLLFunc_Spawn, entity) */
+
+stock fm_velocity_by_aim(index, multiplier, Float:velocity[3]) {
+	new Float:vec[3]
+	pev(index, pev_v_angle, vec)
+	engfunc(EngFunc_MakeVectors, vec)
+	global_get(glb_v_forward, vec)
+
+	velocity[0] = vec[0] * multiplier
+	velocity[1] = vec[1] * multiplier
+	velocity[2] = vec[2] * multiplier
+
+	return 1
+}
+
+// ported by v3x
+#define fm_point_contents(%1) engfunc(EngFunc_PointContents, %1)
+/* stock fm_point_contents(const Float:point[3])
+	return engfunc(EngFunc_PointContents, point) */
+
+stock fm_trace_line(ignoreent, const Float:start[3], const Float:end[3], Float:ret[3]) {
+	engfunc(EngFunc_TraceLine, start, end, ignoreent == -1 ? 1 : 0, ignoreent)
+
+	new ent = global_get(glb_trace_ent)
+	global_get(glb_trace_endpos, ret)
+
+	return pev_valid(ent) ? ent : 0
+}
+
+stock fm_trace_hull(const Float:origin[3], hull, ignoredent = 0, ignoremonsters = 0) {
+	new tr = 0, result = 0
+	engfunc(EngFunc_TraceHull, origin, origin, ignoremonsters, hull, ignoredent > 0 ? ignoredent : 0, tr)
+
+	if (get_tr2(tr, TR_StartSolid))
+		result += 1
+	if (get_tr2(tr, TR_AllSolid))
+		result += 2
+	if (!get_tr2(tr, TR_InOpen))
+		result += 4
+
+	return result
+}
+
+stock fm_trace_normal(ignoreent, const Float:start[3], const Float:end[3], Float:ret[3]) {
+	new tr = 0
+	engfunc(EngFunc_TraceLine, start, end, 0, ignoreent, tr)
+	get_tr2(tr, TR_vecPlaneNormal, ret)
+
+	new Float:fraction
+	get_tr2(tr, TR_flFraction, fraction)
+	if (fraction >= 1.0)
+		return 0
+
+	return 1
+}
+
+#define fm_vector_to_angle(%1,%2) engfunc(EngFunc_VecToAngles, %1, %2)
+/* stock fm_vector_to_angle(const Float:vector[3], Float:anglevec[3])
+	return engfunc(EngFunc_VecToAngles, vector, anglevec) */
+
+stock fm_angle_vector(const Float:vector[3], FRU, Float:ret[3]) {
+	new Float:fwd[3], Float:right[3], Float:up[3]
+	engfunc(EngFunc_AngleVectors, vector, fwd, right, up)
+
+	switch (FRU) {
+		case 1: xs_vec_copy(fwd, ret)
+		case 2: xs_vec_copy(right, ret)
+		case 3: xs_vec_copy(up, ret)
+	}
+
+	return 1
+}
+
+stock Float:fm_vector_length(const Float:vector[3]) {
+	return floatsqroot(vector[0]*vector[0] + vector[1]*vector[1] + vector[2]*vector[2])
+}
+
+#define fm_vector_distance(%1,%2) get_distance_f(%1, %2)
+/* stock Float:fm_vector_distance(const Float:vector1[3], const Float:vector2[3])
+	return get_distance_f(vector1, vector2) */
+
+// note that for CS planted C4 has a "grenade" classname as well
+stock fm_get_grenade_id(id, model[], len, grenadeid = 0) {
+	new ent = fm_find_ent_by_owner(grenadeid, "grenade", id)
+	if (ent && len > 0)
+		pev(ent, pev_model, model, len)
+
+	return ent
+}
+
+#define fm_halflife_time() get_gametime()
+/* stock Float:fm_halflife_time()
+	return get_gametime() */
+
+#define fm_attach_view(%1,%2) engfunc(EngFunc_SetView, %1, %2)
+/* stock fm_attach_view(index, entity)
+	return engfunc(EngFunc_SetView, index, entity) */
+
+stock fm_playback_event(flags, invoker, eventindex, Float:delay, Float:origin[3], Float:angles[3], Float:fparam1, Float:fparam2, iparam1, iparam2, bparam1, bparam2) {
+	return engfunc(EngFunc_PlaybackEvent, flags, invoker, eventindex, delay, origin, angles, fparam1, fparam2, iparam1, iparam2, bparam1, bparam2)
+}
+
+#define fm_eng_get_string(%1,%2,%3) engfunc(EngFunc_SzFromIndex, %1, %2, %3)
+/* stock fm_eng_get_string(istring, string[], len)
+	return engfunc(EngFunc_SzFromIndex, istring, string, len) */
+
+
+/* HLSDK functions */
+
+#define M_PI 3.14159265358979323846 //! should be removed for 1.75
+
+// the dot product is performed in 2d, making the view cone infinitely tall
+stock bool:fm_is_in_viewcone(index, const Float:point[3]) {
+	new Float:angles[3]
+	pev(index, pev_angles, angles)
+	engfunc(EngFunc_MakeVectors, angles)
+	global_get(glb_v_forward, angles)
+	angles[2] = 0.0
+
+	new Float:origin[3], Float:diff[3], Float:norm[3]
+	pev(index, pev_origin, origin)
+	xs_vec_sub(point, origin, diff)
+	diff[2] = 0.0
+	xs_vec_normalize(diff, norm)
+
+	new Float:dot, Float:fov
+	dot = xs_vec_dot(norm, angles)
+	pev(index, pev_fov, fov)
+	if (dot >= floatcos(fov * M_PI / 360))
+		return true
+
+	return false
+}
+
+stock bool:fm_is_visible(index, const Float:point[3]) {
+	new Float:origin[3], Float:view_ofs[3], Float:eyespos[3]
+	pev(index, pev_origin, origin)
+	pev(index, pev_view_ofs, view_ofs)
+	xs_vec_add(origin, view_ofs, eyespos)
+
+	engfunc(EngFunc_TraceLine, eyespos, point, 0, index)
+
+	new Float:fraction
+	global_get(glb_trace_fraction, fraction)
+	if (fraction == 1.0)
+		return true
+
+	return false
+}
+
+
+/* Engine_stocks functions */
+
+stock fm_fakedamage(victim, const classname[], Float:takedmgdamage, damagetype) {
+	new class[] = "trigger_hurt"
+	new entity = fm_create_entity(class)
+	if (!entity)
+		return 0
+
+	new value[16]
+	format(value, 15, "%f", takedmgdamage * 2)
+	fm_set_kvd(entity, "dmg", value, class)
+
+	format(value, 15, "%i", damagetype)
+	fm_set_kvd(entity, "damagetype", value, class)
+
+	fm_set_kvd(entity, "origin", "8192 8192 8192", class)
+	fm_DispatchSpawn(entity)
+
+	set_pev(entity, pev_classname, classname)
+	fm_fake_touch(entity, victim)
+	fm_remove_entity(entity)
+
+	return 1
+}
+
+#define fm_find_ent(%1,%2) engfunc(EngFunc_FindEntityByString, %1, "classname", %2)
+/* stock fm_find_ent(index, const classname[])
+	return engfunc(EngFunc_FindEntityByString, index, "classname", classname) */
+
+stock fm_IVecFVec(const IVec[3], Float:FVec[3]) {
+	FVec[0] = float(IVec[0])
+	FVec[1] = float(IVec[1])
+	FVec[2] = float(IVec[2])
+
+	return 1
+}
+
+stock fm_FVecIVec(const Float:FVec[3], IVec[3]) {
+	IVec[0] = floatround(FVec[0])
+	IVec[1] = floatround(FVec[1])
+	IVec[2] = floatround(FVec[2])
+
+	return 1
+}
+
+#define fm_get_user_button(%1) pev(%1, pev_button)
+/* stock fm_get_user_button(index)
+	return pev(index, pev_button) */
+
+#define fm_get_user_oldbutton(%1) pev(%1, pev_oldbuttons)
+/* stock fm_get_user_oldbutton(index)
+	return pev(index, pev_oldbuttons) */
+
+#define fm_get_entity_flags(%1) pev(%1, pev_flags)
+/* stock fm_get_entity_flags(index)
+	return pev(index, pev_flags) */
+
+#define fm_get_entity_distance(%1,%2) floatround(fm_entity_range(%1, %2))
+/* stock fm_get_entity_distance(ent1, ent2)
+	return floatround(fm_entity_range(ent1, ent2)) */
+
+#define fm_get_grenade(%1) fm_get_grenade_id(%1, "", 0)
+/* stock fm_get_grenade(id)
+	return fm_get_grenade_id(id, "", 0) */
+
+// optimization idea by Orangutanz
+stock fm_get_brush_entity_origin(index, Float:origin[3]) {
+	new Float:mins[3], Float:maxs[3]
+	pev(index, pev_mins, mins)
+	pev(index, pev_maxs, maxs)
+
+	origin[0] = (mins[0] + maxs[0]) * 0.5
+	origin[1] = (mins[1] + maxs[1]) * 0.5
+	origin[2] = (mins[2] + maxs[2]) * 0.5
+
+	return 1
+}
+
+// based on v3x's port, upgraded version returns number of removed entities
+stock fm_remove_entity_name(const classname[]) {
+	new ent = -1, num = 0
+	while ((ent = fm_find_ent_by_class(ent, classname)))
+		num += fm_remove_entity(ent)
+
+	return num
+}
+
+stock fm_ViewContents(id) {
+	new origin[3], Float:Orig[3]
+	get_user_origin(id, origin, 3)
+	fm_IVecFVec(origin, Orig)
+
+	return fm_point_contents(Orig)
+}
+
+stock fm_get_speed(entity) {
+	new Float:Vel[3]
+	pev(entity, pev_velocity, Vel)
+
+	return floatround(fm_vector_length(Vel))
+}
+
+stock fm_make_deathmsg(killer, victim, headshot, /* const */ weapon[]) {
+	message_begin(MSG_ALL, get_user_msgid("DeathMsg"), {0, 0, 0}, 0)
+	write_byte(killer)
+	write_byte(victim)
+
+	new mod_name[32]
+	get_modname(mod_name, 31)
+	if (equal(mod_name, "cstrike") || equal(mod_name, "czero") || equal(mod_name, "csv15") || equal(mod_name, "cs13"))
+		write_byte(headshot)
+
+	write_string(weapon)
+	message_end()
+
+	return 1
+}
+
+stock fm_dod_make_deathmsg(killer, victim, weaponNUM) {
+	message_begin(MSG_ALL, get_user_msgid("DeathMsg"), {0, 0, 0}, 0)
+	write_byte(killer)
+	write_byte(victim)
+	write_byte(weaponNUM)
+	message_end()
+
+	return 1
+}
+
+//! should be uncommented for 1.75
+/*
+stock fm_user_silentkill(index) {
+	set_msg_block(get_user_msgid("DeathMsg"), BLOCK_ONCE)
+	user_kill(index, 1)
+
+	return 1
+}
+*/
+
+stock fm_set_rendering(entity, fx = kRenderFxNone, r = 255, g = 255, b = 255, render = kRenderNormal, amount = 16) {
+	new Float:RenderColor[3]
+	RenderColor[0] = float(r)
+	RenderColor[1] = float(g)
+	RenderColor[2] = float(b)
+
+	set_pev(entity, pev_renderfx, fx)
+	set_pev(entity, pev_rendercolor, RenderColor)
+	set_pev(entity, pev_rendermode, render)
+	set_pev(entity, pev_renderamt, float(amount))
+
+	return 1
+}
+
+stock fm_set_entity_flags(index, flag, onoff) {
+	new flags = pev(index, pev_flags)
+	if ((flags & flag) > 0)
+		return onoff == 1 ? 2 : 1 + 0 * set_pev(index, pev_flags, flags - flag)
+	else
+		return onoff == 0 ? 2 : 1 + 0 * set_pev(index, pev_flags, flags + flag)
+
+	return 0
+}
+
+stock fm_set_entity_visibility(index, visible = 1) {
+	set_pev(index, pev_effects, visible == 1 ? pev(index, pev_effects) & ~EF_NODRAW : pev(index, pev_effects) | EF_NODRAW)
+
+	return 1
+}
+
+#define fm_get_entity_visibility(%1) (!(pev(%1, pev_effects) & EF_NODRAW))
+/* stock fm_get_entity_visibility(index)
+	return !(pev(index, pev_effects) & EF_NODRAW) */
+
+stock fm_set_user_velocity(entity, const Float:vector[3]) {
+	set_pev(entity, pev_velocity, vector)
+
+	return 1
+}
+
+#define fm_get_user_velocity(%1,%2) pev(%1, pev_velocity, %2)
+/* stock fm_get_user_velocity(entity, Float:vector[3])
+	return pev(entity, pev_velocity, vector) */
+
+
+/* Fun functions */
+
+#define fm_get_client_listen(%1,%2) engfunc(EngFunc_GetClientListening, %1, %2)
+/* stock fm_get_client_listen(receiver, sender)
+	return engfunc(EngFunc_GetClientListening, receiver, sender) */
+
+#define fm_set_client_listen(%1,%2,%3) engfunc(EngFunc_SetClientListening, %1, %2, %3)
+/* stock fm_set_client_listen(receiver, sender, listen)
+	return engfunc(EngFunc_SetClientListening, receiver, sender, listen) */
+
+stock fm_get_user_godmode(index) {
+	new Float:val
+	pev(index, pev_takedamage, val)
+
+	return (val == 0.0)
+}
+
+stock fm_set_user_godmode(index, godmode = 0) {
+	set_pev(index, pev_takedamage, godmode == 1 ? 0.0 : 2.0)
+
+	return 1
+}
+
+stock fm_set_user_armor(index, armor) {
+	set_pev(index, pev_armorvalue, float(armor))
+
+	return 1
+}
+
+stock fm_set_user_health(index, health) {
+	health > 0 ? set_pev(index, pev_health, float(health)) : dllfunc(DLLFunc_ClientKill, index)
+
+	return 1
+}
+
+stock fm_set_user_origin(index, const origin[3]) {
+	new Float:orig[3]
+	fm_IVecFVec(origin, orig)
+
+	return fm_entity_set_origin(index, orig)
+}
+
+stock fm_set_user_rendering(index, fx = kRenderFxNone, r = 255, g = 255, b = 255, render = kRenderNormal, amount = 16) {
+	return fm_set_rendering(index, fx, r, g, b, render, amount)
+}
+
+stock fm_give_item(index, const item[]) {
+	if (!equal(item, "weapon_", 7) && !equal(item, "ammo_", 5) && !equal(item, "item_", 5) && !equal(item, "tf_weapon_", 10))
+		return 0
+
+	new ent = fm_create_entity(item)
+	if (!pev_valid(ent))
+		return 0
+
+	new Float:origin[3]
+	pev(index, pev_origin, origin)
+	set_pev(ent, pev_origin, origin)
+	set_pev(ent, pev_spawnflags, pev(ent, pev_spawnflags) | SF_NORESPAWN)
+	dllfunc(DLLFunc_Spawn, ent)
+
+	new save = pev(ent, pev_solid)
+	dllfunc(DLLFunc_Touch, ent, index)
+	if (pev(ent, pev_solid) != save)
+		return ent
+
+	engfunc(EngFunc_RemoveEntity, ent)
+
+	return -1
+}
+
+stock fm_set_user_maxspeed(index, Float:speed = -1.0) {
+	engfunc(EngFunc_SetClientMaxspeed, index, speed)
+	set_pev(index, pev_maxspeed, speed)
+
+	return 1
+}
+
+stock Float:fm_get_user_maxspeed(index) {
+	new Float:speed
+	pev(index, pev_maxspeed, speed)
+
+	return speed
+}
+
+stock fm_set_user_gravity(index, Float:gravity = 1.0) {
+	set_pev(index, pev_gravity, gravity)
+
+	return 1
+}
+
+stock Float:fm_get_user_gravity(index) {
+	new Float:gravity
+	pev(index, pev_gravity, gravity)
+
+	return gravity
+}
+
+/* interferes with FM_Spawn enum, just use fm_DispatchSpawn
+stock fm_spawn(entity) {
+	return dllfunc(DLLFunc_Spawn, entity)
+}
+*/
+
+stock fm_set_user_noclip(index, noclip = 0) {
+	set_pev(index, pev_movetype, noclip == 1 ? MOVETYPE_NOCLIP : MOVETYPE_WALK)
+
+	return 1
+}
+
+#define fm_get_user_noclip(%1) (pev(%1, pev_movetype) == MOVETYPE_NOCLIP)
+/* stock fm_get_user_noclip(index)
+	return (pev(index, pev_movetype) == MOVETYPE_NOCLIP) */
+
+// note: get_user_weapon will still return former weapon index
+stock fm_strip_user_weapons(index) {
+	new ent = fm_create_entity("player_weaponstrip")
+	if (!pev_valid(ent))
+		return 0
+
+	dllfunc(DLLFunc_Spawn, ent)
+	dllfunc(DLLFunc_Use, ent, index)
+	engfunc(EngFunc_RemoveEntity, ent)
+
+	return 1
+}
+
+stock fm_set_user_frags(index, frags) {
+	set_pev(index, pev_frags, float(frags))
+
+	return 1
+}
+
+
+/* Cstrike functions */
+
+stock fm_cs_user_spawn(index) {
+	set_pev(index, pev_deadflag, DEAD_RESPAWNABLE)
+	dllfunc(DLLFunc_Spawn, index)
+	set_pev(index, pev_iuser1, 0)
+
+	return 1
+}
+
+
+/* Other functions */
+
+// based on Basic-Master's set_keyvalue, upgraded version optionally accepts a classname
+stock fm_set_kvd(entity, const key[], const value[], const classname[] = "") {
+	if (classname[0])
+		set_kvd(0, KV_ClassName, classname)
+	else {
+		new class[32]
+		pev(entity, pev_classname, class, 31)
+		set_kvd(0, KV_ClassName, class)
+	}
+
+	set_kvd(0, KV_KeyName, key)
+	set_kvd(0, KV_Value, value)
+	set_kvd(0, KV_fHandled, 0)
+
+	return dllfunc(DLLFunc_KeyValue, entity, 0)
+}
+
+stock fm_find_ent_by_integer(index, pev_field, value) {
+	new maxents = global_get(glb_maxEntities)
+	for (new i = index + 1; i < maxents; ++i) {
+		if (pev_valid(i) && pev(i, pev_field) == value)
+			return i
+	}
+
+	return 0
+}
+
+stock fm_find_ent_by_flags(index, pev_field, flags) {
+	new maxents = global_get(glb_maxEntities)
+	for (new i = index + 1; i < maxents; ++i) {
+		if (pev_valid(i) && (pev(i, pev_field) & flags) == flags)
+			return i
+	}
+
+	return 0
+}
+
+stock Float:fm_distance_to_box(const Float:point[3], const Float:mins[3], const Float:maxs[3]) {
+	new Float:dist[3]
+	for (new i = 0; i < 3; ++i) {
+		if (point[i] > maxs[i])
+			dist[i] = point[i] - maxs[i]
+		else if (mins[i] > point[i])
+			dist[i] = mins[i] - point[i]
+	}
+
+	return fm_vector_length(dist)
+}
+
+stock Float:fm_boxes_distance(const Float:mins1[3], const Float:maxs1[3], const Float:mins2[3], const Float:maxs2[3]) {
+	new Float:dist[3]
+	for (new i = 0; i < 3; ++i) {
+		if (mins1[i] > maxs2[i])
+			dist[i] = mins1[i] - maxs2[i]
+		else if (mins2[i] > maxs1[i])
+			dist[i] = mins2[i] - maxs1[i]
+	}
+
+	return fm_vector_length(dist)
+}
+
+stock Float:fm_distance_to_boxent(entity, boxent) {
+	new Float:point[3]
+	pev(entity, pev_origin, point)
+
+	new Float:mins[3], Float:maxs[3]
+	pev(boxent, pev_absmin, mins)
+	pev(boxent, pev_absmax, maxs)
+
+	return fm_distance_to_box(point, mins, maxs)
+}
+
+stock Float:fm_boxents_distance(boxent1, boxent2) {
+	new Float:mins1[3], Float:maxs1[3]
+	pev(boxent1, pev_absmin, mins1)
+	pev(boxent1, pev_absmax, maxs1)
+
+	new Float:mins2[3], Float:maxs2[3]
+	pev(boxent2, pev_absmin, mins2)
+	pev(boxent2, pev_absmax, maxs2)
+
+	return fm_boxes_distance(mins1, maxs1, mins2, maxs2)
+}
+
+// projects the center of the player's feet base (originally by P34nut, improved)
+stock Float:fm_distance_to_floor(index, ignoremonsters = 1) {
+	new Float:start[3], Float:dest[3], Float:end[3]
+	pev(index, pev_origin, start)
+	dest[0] = start[0]
+	dest[1] = start[1]
+	dest[2] = -8191.0
+
+	engfunc(EngFunc_TraceLine, start, dest, ignoremonsters, index)
+	global_get(glb_trace_endpos, end)
+
+	pev(index, pev_absmin, start)
+	new Float:ret = start[2] - end[2]
+
+	return ret > 0 ? ret : 0.0
+}
+
+stock fm_get_user_weapon_entity(id, wid = 0) {
+	new weap = wid, clip, ammo
+	if (!weap && !(weap = get_user_weapon(id, clip, ammo)))
+		return 0
+	
+	new class[32]
+	get_weaponname(weap, class, 31)
+
+	return fm_find_ent_by_owner(-1, class, id)
+}
+
+stock fm_kill_entity(index) {
+	set_pev(index, pev_flags, pev(index, pev_flags) | FL_KILLME)
+
+	return 1
+}
+
+stock bool:fm_strip_user_gun(index, wid = 0, const wname[] = "") {
+	new ent_class[32]
+	if (!wid && wname[0])
+		copy(ent_class, 31, wname)
+	else {
+		new weapon = wid, clip, ammo
+		if (!weapon && !(weapon = get_user_weapon(index, clip, ammo)))
+			return false
+		
+		get_weaponname(weapon, ent_class, 31)
+	}
+
+	new ent_weap = fm_find_ent_by_owner(-1, ent_class, index)
+	if (!ent_weap)
+		return false
+
+	engclient_cmd(index, "drop", ent_class)
+
+	new ent_box = pev(ent_weap, pev_owner)
+	if (!ent_box || ent_box == index)
+		return false
+
+	dllfunc(DLLFunc_Think, ent_box)
+
+	return true
+}
+
+stock bool:fm_transfer_user_gun(index1, index2, wid = 0, const wname[] = "") {
+	new ent_class[32]
+	if (!wid && wname[0])
+		copy(ent_class, 31, wname)
+	else {
+		new weapon = wid, clip, ammo
+		if (!weapon && !(weapon = get_user_weapon(index1, clip, ammo)))
+			return false
+		
+		get_weaponname(weapon, ent_class, 31)
+	}
+
+	new ent_weap = fm_find_ent_by_owner(-1, ent_class, index1)
+	if (!ent_weap)
+		return false
+
+	engclient_cmd(index1, "drop", ent_class)
+
+	new ent_box = pev(ent_weap, pev_owner)
+	if (!ent_box || ent_box == index1)
+		return false
+
+	set_pev(ent_box, pev_flags, pev(ent_box, pev_flags) | FL_ONGROUND)
+	dllfunc(DLLFunc_Touch, ent_box, index2)
+	if (pev(ent_weap, pev_owner) != index2)
+		return false
+
+	return true
+}
+
+stock bool:fm_is_ent_visible(index, entity) {
+	new Float:origin[3], Float:view_ofs[3], Float:eyespos[3]
+	pev(index, pev_origin, origin)
+	pev(index, pev_view_ofs, view_ofs)
+	xs_vec_add(origin, view_ofs, eyespos)
+
+	new Float:entpos[3]
+	pev(entity, pev_origin, entpos)
+	engfunc(EngFunc_TraceLine, eyespos, entpos, 0, index)
+
+	switch (pev(entity, pev_solid)) {
+		case SOLID_BBOX..SOLID_BSP: return global_get(glb_trace_ent) == entity
+	}
+
+	new Float:fraction
+	global_get(glb_trace_fraction, fraction)
+	if (fraction == 1.0)
+		return true
+
+	return false
+}
+
+// ported from the core's get_user_origin (idea by Greenberet)
+stock fm_get_aim_origin(index, Float:origin[3]) {
+	new Float:start[3], Float:view_ofs[3]
+	pev(index, pev_origin, start)
+	pev(index, pev_view_ofs, view_ofs)
+	xs_vec_add(start, view_ofs, start)
+
+	new Float:dest[3]
+	pev(index, pev_v_angle, dest)
+	engfunc(EngFunc_MakeVectors, dest)
+	global_get(glb_v_forward, dest)
+	xs_vec_mul_scalar(dest, 9999.0, dest)
+	xs_vec_add(start, dest, dest)
+
+	engfunc(EngFunc_TraceLine, start, dest, 0, index)
+	global_get(glb_trace_endpos, origin)
+
+	return 1
+}

fakemeta_util2.inc.txt

@@ -0,0 +1,872 @@
+/* Fakemeta Utilities
+*
+* by VEN
+*
+* This file is provided as is (no warranties).
+*/
+
+#if !defined _fakemeta_included
+	#include <fakemeta>
+#endif
+
+#if defined _fakemeta_util_included
+	#endinput
+#endif
+#define _fakemeta_util_included
+
+#include <xs>
+
+
+/* Engine functions */
+
+#define fm_precache_generic(%1) engfunc(EngFunc_PrecacheGeneric, %1)
+/* stock fm_precache_generic(const file[])
+	return engfunc(EngFunc_PrecacheGeneric, file) */
+
+#define fm_precache_event(%1,%2) engfunc(EngFunc_PrecacheEvent, %1, %2)
+/* stock fm_precache_event(type, const name[])
+	return engfunc(EngFunc_PrecacheEvent, type, name) */
+
+// ported by v3x
+#define fm_drop_to_floor(%1) engfunc(EngFunc_DropToFloor, %1)
+/* stock fm_drop_to_floor(entity)
+	return engfunc(EngFunc_DropToFloor, entity) */
+
+#define fm_force_use(%1,%2) dllfunc(DLLFunc_Use, %2, %1)
+/* stock fm_force_use(user, used)
+	return dllfunc(DLLFunc_Use, used, user) */
+
+#define fm_entity_set_size(%1,%2,%3) engfunc(EngFunc_SetSize, %1, %2, %3)
+/* stock fm_entity_set_size(index, const Float:mins[3], const Float:maxs[3])
+	return engfunc(EngFunc_SetSize, index, mins, maxs) */
+
+#define fm_get_decal_index(%1) engfunc(EngFunc_DecalIndex, %1)
+/* stock fm_get_decal_index(const decalname[])
+	return engfunc(EngFunc_DecalIndex, decalname) */
+
+stock Float:fm_entity_range(ent1, ent2) {
+	new Float:origin1[3], Float:origin2[3]
+	pev(ent1, pev_origin, origin1)
+	pev(ent2, pev_origin, origin2)
+
+	return get_distance_f(origin1, origin2)
+}
+
+// based on KoST's port, upgraded version fits into the macros
+#define fm_create_entity(%1) engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, %1))
+/* stock fm_create_entity(const classname[])
+	return engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, classname)) */
+
+#define fm_find_ent_by_class(%1,%2) engfunc(EngFunc_FindEntityByString, %1, "classname", %2)
+/* stock fm_find_ent_by_class(index, const classname[])
+	return engfunc(EngFunc_FindEntityByString, index, "classname", classname) */
+
+stock fm_find_ent_by_owner(index, const classname[], owner, jghgtype = 0) {
+	new strtype[11] = "classname", ent = index
+	switch (jghgtype) {
+		case 1: strtype = "target"
+		case 2: strtype = "targetname"
+	}
+
+	while ((ent = engfunc(EngFunc_FindEntityByString, ent, strtype, classname)) && pev(ent, pev_owner) != owner) {}
+
+	return ent
+}
+
+#define fm_find_ent_by_target(%1,%2) engfunc(EngFunc_FindEntityByString, %1, "target", %2)
+/* stock fm_find_ent_by_target(index, const target[])
+	return engfunc(EngFunc_FindEntityByString, index, "target", target) */
+
+#define fm_find_ent_by_tname(%1,%2) engfunc(EngFunc_FindEntityByString, %1, "targetname", %2)
+/* stock fm_find_ent_by_tname(index, const targetname[])
+	return engfunc(EngFunc_FindEntityByString, index, "targetname", targetname) */
+
+stock fm_find_ent_by_model(index, const classname[], const model[]) {
+	new ent = index, mdl[72]
+	while ((ent = fm_find_ent_by_class(ent, classname))) {
+		pev(ent, pev_model, mdl, sizeof mdl - 1)
+		if (equal(mdl, model))
+			return ent
+	}
+
+	return 0
+}
+
+#define fm_find_ent_in_sphere(%1,%2,%3) engfunc(EngFunc_FindEntityInSphere, %1, %2, %3)
+/* stock fm_find_ent_in_sphere(index, const Float:origin[3], Float:radius)
+	return engfunc(EngFunc_FindEntityInSphere, index, origin, radius) */
+
+#define fm_call_think(%1) dllfunc(DLLFunc_Think, %1)
+/* stock fm_call_think(entity)
+	return dllfunc(DLLFunc_Think, entity) */
+
+#define fm_is_valid_ent(%1) pev_valid(%1)
+/* stock fm_is_valid_ent(index)
+	return pev_valid(index) */
+
+stock fm_entity_set_origin(index, const Float:origin[3]) {
+	new Float:mins[3], Float:maxs[3]
+	pev(index, pev_mins, mins)
+	pev(index, pev_maxs, maxs)
+	engfunc(EngFunc_SetSize, index, mins, maxs)
+
+	return engfunc(EngFunc_SetOrigin, index, origin)
+}
+
+#define fm_entity_set_model(%1,%2) engfunc(EngFunc_SetModel, %1, %2)
+/* stock fm_entity_set_model(index, const model[])
+	return engfunc(EngFunc_SetModel, index, model) */
+
+// ported by v3x
+#define fm_remove_entity(%1) engfunc(EngFunc_RemoveEntity, %1)
+/* stock fm_remove_entity(index)
+	return engfunc(EngFunc_RemoveEntity, index) */
+
+#define fm_entity_count() engfunc(EngFunc_NumberOfEntities)
+/* stock fm_entity_count()
+	return engfunc(EngFunc_NumberOfEntities) */
+
+#define fm_fake_touch(%1,%2) dllfunc(DLLFunc_Touch, %1, %2)
+/* stock fm_fake_touch(toucher, touched)
+	return dllfunc(DLLFunc_Touch, toucher, touched) */
+
+#define fm_DispatchSpawn(%1) dllfunc(DLLFunc_Spawn, %1)
+/* stock fm_DispatchSpawn(entity)
+	return dllfunc(DLLFunc_Spawn, entity) */
+
+// ported by v3x
+#define fm_point_contents(%1) engfunc(EngFunc_PointContents, %1)
+/* stock fm_point_contents(const Float:point[3])
+	return engfunc(EngFunc_PointContents, point) */
+
+stock fm_trace_line(ignoreent, const Float:start[3], const Float:end[3], Float:ret[3]) {
+	engfunc(EngFunc_TraceLine, start, end, ignoreent == -1 ? 1 : 0, ignoreent, 0)
+
+	new ent = get_tr2(0, TR_pHit)
+	get_tr2(0, TR_vecEndPos, ret)
+
+	return pev_valid(ent) ? ent : 0
+}
+
+stock fm_trace_hull(const Float:origin[3], hull, ignoredent = 0, ignoremonsters = 0) {
+	new result = 0
+	engfunc(EngFunc_TraceHull, origin, origin, ignoremonsters, hull, ignoredent > 0 ? ignoredent : 0, 0)
+
+	if (get_tr2(0, TR_StartSolid))
+		result += 1
+	if (get_tr2(0, TR_AllSolid))
+		result += 2
+	if (!get_tr2(0, TR_InOpen))
+		result += 4
+
+	return result
+}
+
+stock fm_trace_normal(ignoreent, const Float:start[3], const Float:end[3], Float:ret[3]) {
+	engfunc(EngFunc_TraceLine, start, end, 0, ignoreent, 0)
+	get_tr2(0, TR_vecPlaneNormal, ret)
+
+	new Float:fraction
+	get_tr2(0, TR_flFraction, fraction)
+	if (fraction >= 1.0)
+		return 0
+
+	return 1
+}
+
+// note that for CS planted C4 has a "grenade" classname as well
+stock fm_get_grenade_id(id, model[], len, grenadeid = 0) {
+	new ent = fm_find_ent_by_owner(grenadeid, "grenade", id)
+	if (ent && len > 0)
+		pev(ent, pev_model, model, len)
+
+	return ent
+}
+
+#define fm_halflife_time() get_gametime()
+/* stock Float:fm_halflife_time()
+	return get_gametime() */
+
+#define fm_attach_view(%1,%2) engfunc(EngFunc_SetView, %1, %2)
+/* stock fm_attach_view(index, entity)
+	return engfunc(EngFunc_SetView, index, entity) */
+
+stock fm_playback_event(flags, invoker, eventindex, Float:delay, const Float:origin[3], const Float:angles[3], Float:fparam1, Float:fparam2, iparam1, iparam2, bparam1, bparam2) {
+	return engfunc(EngFunc_PlaybackEvent, flags, invoker, eventindex, delay, origin, angles, fparam1, fparam2, iparam1, iparam2, bparam1, bparam2)
+}
+
+#define fm_eng_get_string(%1,%2,%3) engfunc(EngFunc_SzFromIndex, %1, %2, %3)
+/* stock fm_eng_get_string(istring, string[], len)
+	return engfunc(EngFunc_SzFromIndex, istring, string, len) */
+
+
+/* HLSDK functions */
+
+// the dot product is performed in 2d, making the view cone infinitely tall
+stock bool:fm_is_in_viewcone(index, const Float:point[3]) {
+	new Float:angles[3]
+	pev(index, pev_angles, angles)
+	engfunc(EngFunc_MakeVectors, angles)
+	global_get(glb_v_forward, angles)
+	angles[2] = 0.0
+
+	new Float:origin[3], Float:diff[3], Float:norm[3]
+	pev(index, pev_origin, origin)
+	xs_vec_sub(point, origin, diff)
+	diff[2] = 0.0
+	xs_vec_normalize(diff, norm)
+
+	new Float:dot, Float:fov
+	dot = xs_vec_dot(norm, angles)
+	pev(index, pev_fov, fov)
+	if (dot >= floatcos(fov * M_PI / 360))
+		return true
+
+	return false
+}
+
+stock bool:fm_is_visible(index, const Float:point[3], ignoremonsters = 0) {
+	new Float:start[3], Float:view_ofs[3]
+	pev(index, pev_origin, start)
+	pev(index, pev_view_ofs, view_ofs)
+	xs_vec_add(start, view_ofs, start)
+
+	engfunc(EngFunc_TraceLine, start, point, ignoremonsters, index, 0)
+
+	new Float:fraction
+	get_tr2(0, TR_flFraction, fraction)
+	if (fraction == 1.0)
+		return true
+
+	return false
+}
+
+
+/* Engine_stocks functions */
+
+stock fm_fakedamage(victim, const classname[], Float:takedmgdamage, damagetype) {
+	new class[] = "trigger_hurt"
+	new entity = fm_create_entity(class)
+	if (!entity)
+		return 0
+
+	new value[16]
+	float_to_str(takedmgdamage * 2, value, sizeof value - 1)
+	fm_set_kvd(entity, "dmg", value, class)
+
+	num_to_str(damagetype, value, sizeof value - 1)
+	fm_set_kvd(entity, "damagetype", value, class)
+
+	fm_set_kvd(entity, "origin", "8192 8192 8192", class)
+	fm_DispatchSpawn(entity)
+
+	set_pev(entity, pev_classname, classname)
+	fm_fake_touch(entity, victim)
+	fm_remove_entity(entity)
+
+	return 1
+}
+
+#define fm_find_ent(%1,%2) engfunc(EngFunc_FindEntityByString, %1, "classname", %2)
+/* stock fm_find_ent(index, const classname[])
+	return engfunc(EngFunc_FindEntityByString, index, "classname", classname) */
+
+#define fm_get_user_button(%1) pev(%1, pev_button)
+/* stock fm_get_user_button(index)
+	return pev(index, pev_button) */
+
+#define fm_get_user_oldbutton(%1) pev(%1, pev_oldbuttons)
+/* stock fm_get_user_oldbutton(index)
+	return pev(index, pev_oldbuttons) */
+
+#define fm_get_entity_flags(%1) pev(%1, pev_flags)
+/* stock fm_get_entity_flags(index)
+	return pev(index, pev_flags) */
+
+#define fm_get_entity_distance(%1,%2) floatround(fm_entity_range(%1, %2))
+/* stock fm_get_entity_distance(ent1, ent2)
+	return floatround(fm_entity_range(ent1, ent2)) */
+
+#define fm_get_grenade(%1) fm_get_grenade_id(%1, "", 0)
+/* stock fm_get_grenade(id)
+	return fm_get_grenade_id(id, "", 0) */
+
+// optimization idea by Orangutanz
+stock fm_get_brush_entity_origin(index, Float:origin[3]) {
+	new Float:mins[3], Float:maxs[3]
+	pev(index, pev_mins, mins)
+	pev(index, pev_maxs, maxs)
+
+	origin[0] = (mins[0] + maxs[0]) * 0.5
+	origin[1] = (mins[1] + maxs[1]) * 0.5
+	origin[2] = (mins[2] + maxs[2]) * 0.5
+
+	return 1
+}
+
+// based on v3x's port, upgraded version returns number of removed entities
+stock fm_remove_entity_name(const classname[]) {
+	new ent = -1, num = 0
+	while ((ent = fm_find_ent_by_class(ent, classname)))
+		num += fm_remove_entity(ent)
+
+	return num
+}
+
+stock fm_ViewContents(id) {
+	new origin[3], Float:Orig[3]
+	get_user_origin(id, origin, 3)
+	IVecFVec(origin, Orig)
+
+	return fm_point_contents(Orig)
+}
+
+stock fm_get_speed(entity) {
+	new Float:Vel[3]
+	pev(entity, pev_velocity, Vel)
+
+	return floatround(vector_length(Vel))
+}
+
+stock fm_set_rendering(entity, fx = kRenderFxNone, r = 255, g = 255, b = 255, render = kRenderNormal, amount = 16) {
+	new Float:RenderColor[3]
+	RenderColor[0] = float(r)
+	RenderColor[1] = float(g)
+	RenderColor[2] = float(b)
+
+	set_pev(entity, pev_renderfx, fx)
+	set_pev(entity, pev_rendercolor, RenderColor)
+	set_pev(entity, pev_rendermode, render)
+	set_pev(entity, pev_renderamt, float(amount))
+
+	return 1
+}
+
+stock fm_set_entity_flags(index, flag, onoff) {
+	new flags = pev(index, pev_flags)
+	if ((flags & flag) > 0)
+		return onoff == 1 ? 2 : 1 + 0 * set_pev(index, pev_flags, flags - flag)
+	else
+		return onoff == 0 ? 2 : 1 + 0 * set_pev(index, pev_flags, flags + flag)
+
+	return 0
+}
+
+stock fm_set_entity_visibility(index, visible = 1) {
+	set_pev(index, pev_effects, visible == 1 ? pev(index, pev_effects) & ~EF_NODRAW : pev(index, pev_effects) | EF_NODRAW)
+
+	return 1
+}
+
+#define fm_get_entity_visibility(%1) (!(pev(%1, pev_effects) & EF_NODRAW))
+/* stock fm_get_entity_visibility(index)
+	return !(pev(index, pev_effects) & EF_NODRAW) */
+
+stock fm_set_user_velocity(entity, const Float:vector[3]) {
+	set_pev(entity, pev_velocity, vector)
+
+	return 1
+}
+
+#define fm_get_user_velocity(%1,%2) pev(%1, pev_velocity, %2)
+/* stock fm_get_user_velocity(entity, Float:vector[3])
+	return pev(entity, pev_velocity, vector) */
+
+
+/* Fun functions */
+
+#define fm_get_client_listen(%1,%2) engfunc(EngFunc_GetClientListening, %1, %2)
+/* stock fm_get_client_listen(receiver, sender)
+	return engfunc(EngFunc_GetClientListening, receiver, sender) */
+
+#define fm_set_client_listen(%1,%2,%3) engfunc(EngFunc_SetClientListening, %1, %2, %3)
+/* stock fm_set_client_listen(receiver, sender, listen)
+	return engfunc(EngFunc_SetClientListening, receiver, sender, listen) */
+
+stock fm_get_user_godmode(index) {
+	new Float:val
+	pev(index, pev_takedamage, val)
+
+	return (val == DAMAGE_NO)
+}
+
+stock fm_set_user_godmode(index, godmode = 0) {
+	set_pev(index, pev_takedamage, godmode == 1 ? DAMAGE_NO : DAMAGE_AIM)
+
+	return 1
+}
+
+stock fm_set_user_armor(index, armor) {
+	set_pev(index, pev_armorvalue, float(armor))
+
+	return 1
+}
+
+stock fm_set_user_health(index, health) {
+	health > 0 ? set_pev(index, pev_health, float(health)) : dllfunc(DLLFunc_ClientKill, index)
+
+	return 1
+}
+
+stock fm_set_user_origin(index, /* const */ origin[3]) {
+	new Float:orig[3]
+	IVecFVec(origin, orig)
+
+	return fm_entity_set_origin(index, orig)
+}
+
+stock fm_set_user_rendering(index, fx = kRenderFxNone, r = 255, g = 255, b = 255, render = kRenderNormal, amount = 16) {
+	return fm_set_rendering(index, fx, r, g, b, render, amount)
+}
+
+stock fm_give_item(index, const item[]) {
+	if (!equal(item, "weapon_", 7) && !equal(item, "ammo_", 5) && !equal(item, "item_", 5) && !equal(item, "tf_weapon_", 10))
+		return 0
+
+	new ent = fm_create_entity(item)
+	if (!pev_valid(ent))
+		return 0
+
+	new Float:origin[3]
+	pev(index, pev_origin, origin)
+	set_pev(ent, pev_origin, origin)
+	set_pev(ent, pev_spawnflags, pev(ent, pev_spawnflags) | SF_NORESPAWN)
+	dllfunc(DLLFunc_Spawn, ent)
+
+	new save = pev(ent, pev_solid)
+	dllfunc(DLLFunc_Touch, ent, index)
+	if (pev(ent, pev_solid) != save)
+		return ent
+
+	engfunc(EngFunc_RemoveEntity, ent)
+
+	return -1
+}
+
+stock fm_set_user_maxspeed(index, Float:speed = -1.0) {
+	engfunc(EngFunc_SetClientMaxspeed, index, speed)
+	set_pev(index, pev_maxspeed, speed)
+
+	return 1
+}
+
+stock Float:fm_get_user_maxspeed(index) {
+	new Float:speed
+	pev(index, pev_maxspeed, speed)
+
+	return speed
+}
+
+stock fm_set_user_gravity(index, Float:gravity = 1.0) {
+	set_pev(index, pev_gravity, gravity)
+
+	return 1
+}
+
+stock Float:fm_get_user_gravity(index) {
+	new Float:gravity
+	pev(index, pev_gravity, gravity)
+
+	return gravity
+}
+
+/* interferes with FM_Spawn enum, just use fm_DispatchSpawn
+stock fm_spawn(entity) {
+	return dllfunc(DLLFunc_Spawn, entity)
+}
+*/
+
+stock fm_set_user_noclip(index, noclip = 0) {
+	set_pev(index, pev_movetype, noclip == 1 ? MOVETYPE_NOCLIP : MOVETYPE_WALK)
+
+	return 1
+}
+
+#define fm_get_user_noclip(%1) (pev(%1, pev_movetype) == MOVETYPE_NOCLIP)
+/* stock fm_get_user_noclip(index)
+	return (pev(index, pev_movetype) == MOVETYPE_NOCLIP) */
+
+// note: get_user_weapon will still return former weapon index
+stock fm_strip_user_weapons(index) {
+	new ent = fm_create_entity("player_weaponstrip")
+	if (!pev_valid(ent))
+		return 0
+
+	dllfunc(DLLFunc_Spawn, ent)
+	dllfunc(DLLFunc_Use, ent, index)
+	engfunc(EngFunc_RemoveEntity, ent)
+
+	return 1
+}
+
+stock fm_set_user_frags(index, frags) {
+	set_pev(index, pev_frags, float(frags))
+
+	return 1
+}
+
+
+/* Cstrike functions */
+
+stock fm_cs_user_spawn(index) {
+	set_pev(index, pev_deadflag, DEAD_RESPAWNABLE)
+	dllfunc(DLLFunc_Spawn, index)
+	set_pev(index, pev_iuser1, 0)
+
+	return 1
+}
+
+
+/* Custom functions */
+
+// based on Basic-Master's set_keyvalue, upgraded version accepts an optional classname (a bit more efficient if it is passed)
+stock fm_set_kvd(entity, const key[], const value[], const classname[] = "") {
+	if (classname[0])
+		set_kvd(0, KV_ClassName, classname)
+	else {
+		new class[32]
+		pev(entity, pev_classname, class, sizeof class - 1)
+		set_kvd(0, KV_ClassName, class)
+	}
+
+	set_kvd(0, KV_KeyName, key)
+	set_kvd(0, KV_Value, value)
+	set_kvd(0, KV_fHandled, 0)
+
+	return dllfunc(DLLFunc_KeyValue, entity, 0)
+}
+
+stock fm_find_ent_by_integer(index, pev_field, value) {
+	static maxents
+	if (!maxents)
+		maxents = global_get(glb_maxEntities)
+
+	for (new i = index + 1; i < maxents; ++i) {
+		if (pev_valid(i) && pev(i, pev_field) == value)
+			return i
+	}
+
+	return 0
+}
+
+stock fm_find_ent_by_flags(index, pev_field, flags) {
+	static maxents
+	if (!maxents)
+		maxents = global_get(glb_maxEntities)
+
+	for (new i = index + 1; i < maxents; ++i) {
+		if (pev_valid(i) && (pev(i, pev_field) & flags) == flags)
+			return i
+	}
+
+	return 0
+}
+
+stock Float:fm_distance_to_box(const Float:point[3], const Float:mins[3], const Float:maxs[3]) {
+	new Float:dist[3]
+	for (new i = 0; i < 3; ++i) {
+		if (point[i] > maxs[i])
+			dist[i] = point[i] - maxs[i]
+		else if (mins[i] > point[i])
+			dist[i] = mins[i] - point[i]
+	}
+
+	return vector_length(dist)
+}
+
+stock Float:fm_boxes_distance(const Float:mins1[3], const Float:maxs1[3], const Float:mins2[3], const Float:maxs2[3]) {
+	new Float:dist[3]
+	for (new i = 0; i < 3; ++i) {
+		if (mins1[i] > maxs2[i])
+			dist[i] = mins1[i] - maxs2[i]
+		else if (mins2[i] > maxs1[i])
+			dist[i] = mins2[i] - maxs1[i]
+	}
+
+	return vector_length(dist)
+}
+
+stock Float:fm_distance_to_boxent(entity, boxent) {
+	new Float:point[3]
+	pev(entity, pev_origin, point)
+
+	new Float:mins[3], Float:maxs[3]
+	pev(boxent, pev_absmin, mins)
+	pev(boxent, pev_absmax, maxs)
+
+	return fm_distance_to_box(point, mins, maxs)
+}
+
+stock Float:fm_boxents_distance(boxent1, boxent2) {
+	new Float:mins1[3], Float:maxs1[3]
+	pev(boxent1, pev_absmin, mins1)
+	pev(boxent1, pev_absmax, maxs1)
+
+	new Float:mins2[3], Float:maxs2[3]
+	pev(boxent2, pev_absmin, mins2)
+	pev(boxent2, pev_absmax, maxs2)
+
+	return fm_boxes_distance(mins1, maxs1, mins2, maxs2)
+}
+
+// projects a center of a player's feet base (originally by P34nut, improved)
+stock Float:fm_distance_to_floor(index, ignoremonsters = 1) {
+	new Float:start[3], Float:dest[3], Float:end[3]
+	pev(index, pev_origin, start)
+	dest[0] = start[0]
+	dest[1] = start[1]
+	dest[2] = -8191.0
+
+	engfunc(EngFunc_TraceLine, start, dest, ignoremonsters, index, 0)
+	get_tr2(0, TR_vecEndPos, end)
+
+	pev(index, pev_absmin, start)
+	new Float:ret = start[2] - end[2]
+
+	return ret > 0 ? ret : 0.0
+}
+
+// potential to crash (?) if used on weaponbox+weapon_* entity pair (use fm_remove_weaponbox instead)
+stock fm_kill_entity(index) {
+	set_pev(index, pev_flags, pev(index, pev_flags) | FL_KILLME)
+
+	return 1
+}
+
+// if weapon index isn't passed then assuming that it's the current weapon
+stock fm_get_user_weapon_entity(id, wid = 0) {
+	new weap = wid, clip, ammo
+	if (!weap && !(weap = get_user_weapon(id, clip, ammo)))
+		return 0
+	
+	new class[32]
+	get_weaponname(weap, class, sizeof class - 1)
+
+	return fm_find_ent_by_owner(-1, class, id)
+}
+
+// only weapon index or its name can be passed, if neither is passed then the current gun will be stripped
+stock bool:fm_strip_user_gun(index, wid = 0, const wname[] = "") {
+	new ent_class[32]
+	if (!wid && wname[0])
+		copy(ent_class, sizeof ent_class - 1, wname)
+	else {
+		new weapon = wid, clip, ammo
+		if (!weapon && !(weapon = get_user_weapon(index, clip, ammo)))
+			return false
+		
+		get_weaponname(weapon, ent_class, sizeof ent_class - 1)
+	}
+
+	new ent_weap = fm_find_ent_by_owner(-1, ent_class, index)
+	if (!ent_weap)
+		return false
+
+	engclient_cmd(index, "drop", ent_class)
+
+	new ent_box = pev(ent_weap, pev_owner)
+	if (!ent_box || ent_box == index)
+		return false
+
+	dllfunc(DLLFunc_Think, ent_box)
+
+	return true
+}
+
+// only weapon index or its name can be passed, if neither is passed then the current gun will be transferred
+stock bool:fm_transfer_user_gun(index1, index2, wid = 0, const wname[] = "") {
+	new ent_class[32]
+	if (!wid && wname[0])
+		copy(ent_class, sizeof ent_class - 1, wname)
+	else {
+		new weapon = wid, clip, ammo
+		if (!weapon && !(weapon = get_user_weapon(index1, clip, ammo)))
+			return false
+		
+		get_weaponname(weapon, ent_class, sizeof ent_class - 1)
+	}
+
+	new ent_weap = fm_find_ent_by_owner(-1, ent_class, index1)
+	if (!ent_weap)
+		return false
+
+	engclient_cmd(index1, "drop", ent_class)
+
+	new ent_box = pev(ent_weap, pev_owner)
+	if (!ent_box || ent_box == index1)
+		return false
+
+	set_pev(ent_box, pev_flags, pev(ent_box, pev_flags) | FL_ONGROUND)
+	dllfunc(DLLFunc_Touch, ent_box, index2)
+	if (pev(ent_weap, pev_owner) != index2)
+		return false
+
+	return true
+}
+
+stock bool:fm_is_ent_visible(index, entity, ignoremonsters = 0) {
+	new Float:start[3], Float:dest[3]
+	pev(index, pev_origin, start)
+	pev(index, pev_view_ofs, dest)
+	xs_vec_add(start, dest, start)
+
+	pev(entity, pev_origin, dest)
+	engfunc(EngFunc_TraceLine, start, dest, ignoremonsters, index, 0)
+
+	new Float:fraction
+	get_tr2(0, TR_flFraction, fraction)
+	if (fraction == 1.0 || get_tr2(0, TR_pHit) == entity)
+		return true
+
+	return false
+}
+
+// ported from AMXX's core get_user_origin(..., 3) (suggested by Greenberet)
+stock fm_get_aim_origin(index, Float:origin[3]) {
+	new Float:start[3], Float:view_ofs[3]
+	pev(index, pev_origin, start)
+	pev(index, pev_view_ofs, view_ofs)
+	xs_vec_add(start, view_ofs, start)
+
+	new Float:dest[3]
+	pev(index, pev_v_angle, dest)
+	engfunc(EngFunc_MakeVectors, dest)
+	global_get(glb_v_forward, dest)
+	xs_vec_mul_scalar(dest, 9999.0, dest)
+	xs_vec_add(start, dest, dest)
+
+	engfunc(EngFunc_TraceLine, start, dest, 0, index, 0)
+	get_tr2(0, TR_vecEndPos, origin)
+
+	return 1
+}
+
+stock bool:fm_get_user_longjump(index) {
+	new value[2]
+	engfunc(EngFunc_GetPhysicsKeyValue, index, "slj", value, 1)
+	switch (value[0]) {
+		case '1': return true
+	}
+
+	return false
+}
+
+stock fm_set_user_longjump(index, bool:longjump = true, bool:tempicon = true) {
+	if (longjump == fm_get_user_longjump(index))
+		return
+
+	if (longjump) {
+		engfunc(EngFunc_SetPhysicsKeyValue, index, "slj", "1")
+		if (tempicon) {
+			static msgid_itempickup
+			if (!msgid_itempickup)
+				msgid_itempickup = get_user_msgid("ItemPickup")
+
+			message_begin(MSG_ONE, msgid_itempickup, _, index)
+			write_string("item_longjump")
+			message_end()
+		}
+	}
+	else
+		engfunc(EngFunc_SetPhysicsKeyValue, index, "slj", "0")
+}
+
+#define WEAPON_SUIT 31
+
+stock bool:fm_get_user_suit(index) {
+	return bool:(!(!(pev(index, pev_weapons) & (1<<WEAPON_SUIT)))) // i'm not insane, this is a trick!
+}
+
+stock fm_set_user_suit(index, bool:suit = true, bool:sound = true) {
+	new weapons = pev(index, pev_weapons)
+	if (!suit)
+		set_pev(index, pev_weapons, weapons & ~(1<<WEAPON_SUIT))
+	else if (!(weapons & (1<<WEAPON_SUIT))) {
+		set_pev(index, pev_weapons, weapons | (1<<WEAPON_SUIT))
+		if (sound)
+			emit_sound(index, CHAN_VOICE, "items/tr_kevlar.wav", VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
+	}
+}
+
+#define FEV_RELIABLE (1<<1)
+#define FEV_GLOBAL (1<<2)
+
+// removes all created decals and players' corpses from the world
+// set a specific index to remove decals only for the given client
+stock fm_cs_remove_decals(index = 0) {
+	static eventindex_decal_reset
+	if (!eventindex_decal_reset)
+		eventindex_decal_reset = engfunc(EngFunc_PrecacheEvent, 1, "events/decal_reset.sc")
+
+	new flags = FEV_RELIABLE
+	if (!index)
+		flags |= FEV_GLOBAL
+
+	engfunc(EngFunc_PlaybackEvent, flags, index, eventindex_decal_reset, 0.0, Float:{0.0, 0.0, 0.0}, Float:{0.0, 0.0, 0.0}, 0.0, 0.0, 0, 0, 0, 0)
+}
+
+// checks whether the entity's classname is equal to the passed classname
+stock bool:fm_is_ent_classname(index, const classname[]) {
+	if (!pev_valid(index))
+		return false
+
+	new class[32]
+	pev(index, pev_classname, class, sizeof class - 1)
+	if (equal(class, classname))
+		return true
+
+	return false
+}
+
+// the same as AMXX's core user_kill but fixes the issue when the scoreboard doesn't update immediately if flag is set to 1
+stock fm_user_kill(index, flag = 0) {
+	if (flag) {
+		new Float:frags
+		pev(index, pev_frags, frags)
+		set_pev(index, pev_frags, ++frags)
+	}
+
+	dllfunc(DLLFunc_ClientKill, index)
+
+	return 1
+}
+
+// returns a degree angle between player-to-point and player's view vectors
+stock Float:fm_get_view_angle_diff(index, const Float:point[3]) {
+	new Float:vec[3], Float:ofs[3], Float:aim[3]
+	pev(index, pev_origin, vec)
+	pev(index, pev_view_ofs, ofs)
+	xs_vec_add(vec, ofs, vec)
+	xs_vec_sub(point, vec, vec)
+	xs_vec_normalize(vec, vec)
+
+	pev(index, pev_v_angle, aim)
+	engfunc(EngFunc_MakeVectors, aim)
+	global_get(glb_v_forward, aim)
+
+	return xs_vec_angle(vec, aim)
+}
+
+// gets a weapon type of the linked to weaponbox weapon_* entity
+stock fm_get_weaponbox_type(entity) {
+	static max_clients, max_entities
+	if (!max_clients)
+		max_clients = global_get(glb_maxClients)
+	if (!max_entities)
+		max_entities = global_get(glb_maxEntities)
+
+	for (new i = max_clients + 1; i < max_entities; ++i) {
+		if (pev_valid(i) && entity == pev(i, pev_owner)) {
+			new wname[32]
+			pev(i, pev_classname, wname, sizeof wname - 1)
+			return get_weaponid(wname)
+		}
+	}
+
+	return 0
+}
+
+// safe removal of weaponbox+weapon_* entity pair (delay =~= 0.03 second)
+#define fm_remove_weaponbox(%1) dllfunc(DLLFunc_Think, %1)
+/* stock fm_remove_weaponbox(entity)
+	return dllfunc(DLLFunc_Think, entity) */

hldsk_const.inc.txt

@@ -0,0 +1,437 @@
+/* Half-Life Software Development Kit constants
+*
+* by the AMX Mod X Development Team
+*
+* This file is provided as is (no warranties).
+*
+*/
+
+#if defined _hlsdk_const_included
+	#endinput
+#endif
+#define _hlsdk_const_included
+
+// pev(entity, pev_button) or pev(entity, pev_oldbuttons) values
+#define IN_ATTACK                       (1<<0)
+#define IN_JUMP                         (1<<1)
+#define IN_DUCK                         (1<<2)
+#define IN_FORWARD                      (1<<3)
+#define IN_BACK                         (1<<4)
+#define IN_USE                          (1<<5)
+#define IN_CANCEL                       (1<<6)
+#define IN_LEFT                         (1<<7)
+#define IN_RIGHT                        (1<<8)
+#define IN_MOVELEFT                     (1<<9)
+#define IN_MOVERIGHT                    (1<<10)
+#define IN_ATTACK2                      (1<<11)
+#define IN_RUN                          (1<<12)
+#define IN_RELOAD                       (1<<13)
+#define IN_ALT1                         (1<<14)
+#define IN_SCORE                        (1<<15)     // Used by client.dll for when scoreboard is held down
+
+// pev(entity, pev_flags) values
+#define	FL_FLY                          (1<<0)      // Changes the SV_Movestep() behavior to not need to be on ground
+#define	FL_SWIM                         (1<<1)      // Changes the SV_Movestep() behavior to not need to be on ground (but stay in water)
+#define	FL_CONVEYOR                     (1<<2)
+#define	FL_CLIENT                       (1<<3)
+#define	FL_INWATER                      (1<<4)
+#define	FL_MONSTER                      (1<<5)
+#define	FL_GODMODE                      (1<<6)
+#define	FL_NOTARGET                     (1<<7)
+#define	FL_SKIPLOCALHOST                (1<<8)      // Don't send entity to local host, it's predicting this entity itself
+#define	FL_ONGROUND	                    (1<<9)      // At rest / on the ground
+#define	FL_PARTIALGROUND                (1<<10)     // Not all corners are valid
+#define	FL_WATERJUMP                    (1<<11)     // Player jumping out of water
+#define FL_FROZEN                       (1<<12)     // Player is frozen for 3rd person camera
+#define FL_FAKECLIENT                   (1<<13)     // JAC: fake client, simulated server side; don't send network messages to them
+#define FL_DUCKING                      (1<<14)     // Player flag -- Player is fully crouched
+#define FL_FLOAT                        (1<<15)     // Apply floating force to this entity when in water
+#define FL_GRAPHED                      (1<<16)     // Worldgraph has this ent listed as something that blocks a connection
+#define FL_IMMUNE_WATER                 (1<<17)
+#define	FL_IMMUNE_SLIME                 (1<<18)
+#define FL_IMMUNE_LAVA                  (1<<19)
+#define FL_PROXY                        (1<<20)     // This is a spectator proxy
+#define FL_ALWAYSTHINK                  (1<<21)     // Brush model flag -- call think every frame regardless of nextthink - ltime (for constantly changing velocity/path)
+#define FL_BASEVELOCITY                 (1<<22)     // Base velocity has been applied this frame (used to convert base velocity into momentum)
+#define FL_MONSTERCLIP                  (1<<23)     // Only collide in with monsters who have FL_MONSTERCLIP set
+#define FL_ONTRAIN                      (1<<24)     // Player is _controlling_ a train, so movement commands should be ignored on client during prediction.
+#define FL_WORLDBRUSH                   (1<<25)     // Not moveable/removeable brush entity (really part of the world, but represented as an entity for transparency or something)
+#define FL_SPECTATOR                    (1<<26)     // This client is a spectator, don't run touch functions, etc.
+#define FL_CUSTOMENTITY                 (1<<29)     // This is a custom entity
+#define FL_KILLME                       (1<<30)     // This entity is marked for death -- This allows the engine to kill ents at the appropriate time
+#define FL_DORMANT                      (1<<31)     // Entity is dormant, no updates to client
+
+// engfunc(EngFunc_WalkMove, entity, Float:yaw, Float:dist, iMode) iMode values
+#define	WALKMOVE_NORMAL                 0           // Normal walkmove
+#define WALKMOVE_WORLDONLY              1           // Doesn't hit ANY entities, no matter what the solid type
+#define WALKMOVE_CHECKONLY              2           // Move, but don't touch triggers
+
+// pev(entity, pev_movetype) values
+#define	MOVETYPE_NONE                   0           // Never moves
+#define	MOVETYPE_WALK                   3           // Player only - moving on the ground
+#define	MOVETYPE_STEP                   4           // Gravity, special edge handling -- monsters use this
+#define	MOVETYPE_FLY                    5           // No gravity, but still collides with stuff
+#define	MOVETYPE_TOSS                   6           // Gravity/Collisions
+#define	MOVETYPE_PUSH                   7           // No clip to world, push and crush
+#define	MOVETYPE_NOCLIP                 8           // No gravity, no collisions, still do velocity/avelocity
+#define	MOVETYPE_FLYMISSILE             9           // Extra size to monsters
+#define	MOVETYPE_BOUNCE                 10          // Just like Toss, but reflect velocity when contacting surfaces
+#define MOVETYPE_BOUNCEMISSILE          11          // Bounce w/o gravity
+#define MOVETYPE_FOLLOW                 12          // Track movement of aiment
+#define	MOVETYPE_PUSHSTEP               13          // BSP model that needs physics/world collisions (uses nearest hull for world collision)
+
+// pev(entity, pev_solid) values
+// NOTE: Some movetypes will cause collisions independent of SOLID_NOT/SOLID_TRIGGER when the entity moves
+// SOLID only effects OTHER entities colliding with this one when they move - UGH!
+#define	SOLID_NOT                       0           // No interaction with other objects
+#define	SOLID_TRIGGER                   1           // Touch on edge, but not blocking
+#define	SOLID_BBOX                      2           // Touch on edge, block
+#define	SOLID_SLIDEBOX                  3           // Touch on edge, but not an onground
+#define	SOLID_BSP                       4           // BSP clip, touch on edge, block
+
+// pev(entity, pev_deadflag) values
+#define	DEAD_NO                         0           // Alive
+#define	DEAD_DYING                      1           // Playing death animation or still falling off of a ledge waiting to hit ground
+#define	DEAD_DEAD                       2           // Dead, lying still
+#define DEAD_RESPAWNABLE                3
+#define DEAD_DISCARDBODY                4
+
+// new Float:takedamage, pev(entity, pev_takedamage, takedamage) values
+#define	DAMAGE_NO                       0.0
+#define	DAMAGE_YES                      1.0
+#define	DAMAGE_AIM                      2.0
+
+// pev(entity, pev_effects) values
+#define	EF_BRIGHTFIELD                  1           // Swirling cloud of particles
+#define	EF_MUZZLEFLASH                  2           // Single frame ELIGHT on entity attachment 0
+#define	EF_BRIGHTLIGHT                  4           // DLIGHT centered at entity origin
+#define	EF_DIMLIGHT                     8           // Player flashlight
+#define EF_INVLIGHT                     16          // Get lighting from ceiling
+#define EF_NOINTERP                     32          // Don't interpolate the next frame
+#define EF_LIGHT                        64          // Rocket flare glow sprite
+#define EF_NODRAW                       128         // Don't draw entity
+
+// engfunc(EngFunc_PointContents, Float:origin) return values
+#define	CONTENTS_EMPTY                  -1
+#define	CONTENTS_SOLID                  -2
+#define	CONTENTS_WATER                  -3
+#define	CONTENTS_SLIME                  -4
+#define	CONTENTS_LAVA                   -5
+#define	CONTENTS_SKY                    -6
+#define	CONTENTS_ORIGIN                 -7          // Removed at csg time
+#define	CONTENTS_CLIP                   -8          // Changed to contents_solid
+#define	CONTENTS_CURRENT_0              -9
+#define	CONTENTS_CURRENT_90             -10
+#define	CONTENTS_CURRENT_180            -11
+#define	CONTENTS_CURRENT_270            -12
+#define	CONTENTS_CURRENT_UP             -13
+#define	CONTENTS_CURRENT_DOWN           -14
+#define CONTENTS_TRANSLUCENT            -15
+#define	CONTENTS_LADDER                 -16
+#define	CONTENT_FLYFIELD                -17
+#define	CONTENT_GRAVITY_FLYFIELD        -18
+#define	CONTENT_FOG                     -19
+
+// Instant damage values for use with gmsgDamage 3rd value write_long(BIT)
+#define DMG_GENERIC                     0           // Generic damage was done
+#define DMG_CRUSH                       (1<<0)      // Crushed by falling or moving object
+#define DMG_BULLET                      (1<<1)      // Shot
+#define DMG_SLASH                       (1<<2)      // Cut, clawed, stabbed
+#define DMG_BURN                        (1<<3)      // Heat burned
+#define DMG_FREEZE                      (1<<4)      // Frozen
+#define DMG_FALL                        (1<<5)      // Fell too far
+#define DMG_BLAST                       (1<<6)      // Explosive blast damage
+#define DMG_CLUB                        (1<<7)      // Crowbar, punch, headbutt
+#define DMG_SHOCK                       (1<<8)      // Electric shock
+#define DMG_SONIC                       (1<<9)      // Sound pulse shockwave
+#define DMG_ENERGYBEAM                  (1<<10)     // Laser or other high energy beam 
+#define DMG_NEVERGIB                    (1<<12)     // With this bit OR'd in, no damage type will be able to gib victims upon death
+#define DMG_ALWAYSGIB                   (1<<13)     // With this bit OR'd in, any damage type can be made to gib victims upon death.
+#define DMG_DROWN                       (1<<14)     // Drowning
+#define DMG_PARALYZE                    (1<<15)     // Slows affected creature down
+#define DMG_NERVEGAS                    (1<<16)     // Nerve toxins, very bad
+#define DMG_POISON                      (1<<17)     // Blood poisioning
+#define DMG_RADIATION                   (1<<18)     // Radiation exposure
+#define DMG_DROWNRECOVER                (1<<19)     // Drowning recovery
+#define DMG_ACID                        (1<<20)     // Toxic chemicals or acid burns
+#define DMG_SLOWBURN                    (1<<21)     // In an oven
+#define DMG_SLOWFREEZE                  (1<<22)     // In a subzero freezer
+#define DMG_MORTAR                      (1<<23)     // Hit by air raid (done to distinguish grenade from mortar)
+#define DMG_TIMEBASED                   (~(0x3fff)) // Mask for time-based damage
+
+// The hullnumber paramater of EngFunc_TraceHull, EngFunc_TraceModel and DLLFunc_GetHullBounds
+#define HULL_POINT                      0
+#define HULL_HUMAN                      1
+#define HULL_LARGE                      2
+#define HULL_HEAD                       3
+
+// global_get(glb_trace_flags)
+#define FTRACE_SIMPLEBOX                (1<<0)      // Traceline with a simple box
+
+// Used with get/set_es(es_handle, ES_eFlags, ...) (entity_state data structure)
+#define EFLAG_SLERP                     1           // Do studio interpolation of this entity
+
+// pev(entity, pev_spawnflags) values
+// Many of these flags apply to specific entities
+// func_train
+#define	SF_TRAIN_WAIT_RETRIGGER         1
+#define SF_TRAIN_START_ON               4           // Train is initially moving
+#define SF_TRAIN_PASSABLE               8           // Train is not solid -- used to make water trains
+
+// func_wall_toggle
+#define SF_WALL_START_OFF               0x0001
+
+// func_converyor
+#define SF_CONVEYOR_VISUAL              0x0001
+#define SF_CONVEYOR_NOTSOLID            0x0002
+
+// func_button
+#define SF_BUTTON_DONTMOVE              1
+#define	SF_BUTTON_TOGGLE                32          // Button stays pushed until reactivated
+#define	SF_BUTTON_SPARK_IF_OFF          64          // Button sparks in OFF state
+#define SF_BUTTON_TOUCH_ONLY            256         // Button only fires as a result of USE key.
+
+// func_rot_button
+#define SF_ROTBUTTON_NOTSOLID           1
+
+// env_global
+#define SF_GLOBAL_SET                   1           // Set global state to initial state on spawn
+
+// multisource
+#define SF_MULTI_INIT                   1
+
+// momentary_rot_button
+#define SF_MOMENTARY_DOOR               0x0001
+
+// button_target
+#define SF_BTARGET_USE                  0x0001
+#define SF_BTARGET_ON                   0x0002
+
+// func_door, func_water, func_door_rotating, momementary_door
+#define SF_DOOR_ROTATE_Y                0
+#define	SF_DOOR_START_OPEN              1
+#define SF_DOOR_ROTATE_BACKWARDS        2
+#define SF_DOOR_PASSABLE                8
+#define SF_DOOR_ONEWAY                  16
+#define	SF_DOOR_NO_AUTO_RETURN          32
+#define SF_DOOR_ROTATE_Z                64
+#define SF_DOOR_ROTATE_X                128
+#define SF_DOOR_USE_ONLY                256         // Door must be opened by player's use button
+#define SF_DOOR_NOMONSTERS              512         // Monster can't open
+#define SF_DOOR_SILENT                  0x80000000
+
+// gibshooter
+#define	SF_GIBSHOOTER_REPEATABLE        1           // Allows a gibshooter to be refired
+
+// env_funnel
+#define SF_FUNNEL_REVERSE               1           // Funnel effect repels particles instead of attracting them
+
+// env_bubbles
+#define SF_BUBBLES_STARTOFF             0x0001
+
+// env_blood
+#define SF_BLOOD_RANDOM                 0x0001
+#define SF_BLOOD_STREAM                 0x0002
+#define SF_BLOOD_PLAYER                 0x0004
+#define SF_BLOOD_DECAL                  0x0008
+
+// env_shake
+#define SF_SHAKE_EVERYONE               0x0001      // Don't check radius
+#define SF_SHAKE_DISRUPT                0x0002      // Disrupt controls
+#define SF_SHAKE_INAIR                  0x0004      // Shake players in air
+
+// env_fade
+#define SF_FADE_IN                      0x0001      // Fade in, not out
+#define SF_FADE_MODULATE                0x0002      // Modulate, don't blend
+#define SF_FADE_ONLYONE                 0x0004
+
+// env_beam, env_lightning
+#define SF_BEAM_STARTON                 0x0001
+#define SF_BEAM_TOGGLE                  0x0002
+#define SF_BEAM_RANDOM                  0x0004
+#define SF_BEAM_RING                    0x0008
+#define SF_BEAM_SPARKSTART              0x0010
+#define SF_BEAM_SPARKEND                0x0020
+#define SF_BEAM_DECALS                  0x0040
+#define SF_BEAM_SHADEIN                 0x0080
+#define SF_BEAM_SHADEOUT                0x0100
+#define SF_BEAM_TEMPORARY               0x8000
+
+// env_sprite
+#define SF_SPRITE_STARTON               0x0001
+#define SF_SPRITE_ONCE                  0x0002
+#define SF_SPRITE_TEMPORARY             0x8000
+
+// env_message
+#define SF_MESSAGE_ONCE                 0x0001      // Fade in, not out
+#define SF_MESSAGE_ALL                  0x0002      // Send to all clients
+
+// env_explosion
+#define	SF_ENVEXPLOSION_NODAMAGE        (1<<0)      // When set, ENV_EXPLOSION will not actually inflict damage
+#define	SF_ENVEXPLOSION_REPEATABLE      (1<<1)      // Can this entity be refired?
+#define SF_ENVEXPLOSION_NOFIREBALL      (1<<2)      // Don't draw the fireball
+#define SF_ENVEXPLOSION_NOSMOKE         (1<<3)      // Don't draw the smoke
+#define SF_ENVEXPLOSION_NODECAL         (1<<4)      // Don't make a scorch mark
+#define SF_ENVEXPLOSION_NOSPARKS        (1<<5)      // Don't make a scorch mark
+
+// func_tank
+#define SF_TANK_ACTIVE                  0x0001
+#define SF_TANK_PLAYER                  0x0002
+#define SF_TANK_HUMANS                  0x0004
+#define SF_TANK_ALIENS                  0x0008
+#define SF_TANK_LINEOFSIGHT             0x0010
+#define SF_TANK_CANCONTROL              0x0020
+#define SF_TANK_SOUNDON                 0x8000
+
+// grenade
+#define SF_DETONATE                     0x0001
+
+// item_suit
+#define SF_SUIT_SHORTLOGON              0x0001
+
+// game_score
+#define SF_SCORE_NEGATIVE               0x0001
+#define SF_SCORE_TEAM                   0x0002
+
+// game_text
+#define SF_ENVTEXT_ALLPLAYERS           0x0001
+
+// game_team_master
+#define SF_TEAMMASTER_FIREONCE          0x0001
+#define SF_TEAMMASTER_ANYTEAM           0x0002
+
+// game_team_set
+#define SF_TEAMSET_FIREONCE             0x0001
+#define SF_TEAMSET_CLEARTEAM            0x0002
+
+// game_player_hurt
+#define SF_PKILL_FIREONCE               0x0001
+
+// game_counter
+#define SF_GAMECOUNT_FIREONCE           0x0001
+#define SF_GAMECOUNT_RESET              0x0002
+
+// game_player_equip
+#define SF_PLAYEREQUIP_USEONLY          0x0001
+
+// game_player_team
+#define SF_PTEAM_FIREONCE               0x0001
+#define SF_PTEAM_KILL                   0x0002
+#define SF_PTEAM_GIB                    0x0004
+
+// func_trackchange
+#define SF_PLAT_TOGGLE                  0x0001
+#define SF_TRACK_ACTIVATETRAIN          0x00000001
+#define SF_TRACK_RELINK                 0x00000002
+#define SF_TRACK_ROTMOVE                0x00000004
+#define SF_TRACK_STARTBOTTOM            0x00000008
+#define SF_TRACK_DONT_MOVE              0x00000010
+
+// func_tracktrain
+#define SF_TRACKTRAIN_NOPITCH           0x0001
+#define SF_TRACKTRAIN_NOCONTROL         0x0002
+#define SF_TRACKTRAIN_FORWARDONLY       0x0004
+#define SF_TRACKTRAIN_PASSABLE          0x0008
+#define SF_PATH_DISABLED                0x00000001
+#define SF_PATH_FIREONCE                0x00000002
+#define SF_PATH_ALTREVERSE              0x00000004
+#define SF_PATH_DISABLE_TRAIN           0x00000008
+#define SF_PATH_ALTERNATE               0x00008000
+#define SF_CORNER_WAITFORTRIG           0x001
+#define SF_CORNER_TELEPORT              0x002
+#define SF_CORNER_FIREONCE              0x004
+
+// trigger_push
+#define	SF_TRIGGER_PUSH_START_OFF       2           // Spawnflag that makes trigger_push spawn turned OFF
+
+// trigger_hurt
+#define SF_TRIGGER_HURT_TARGETONCE      1           // Only fire hurt target once
+#define	SF_TRIGGER_HURT_START_OFF       2           // Spawnflag that makes trigger_push spawn turned OFF
+#define	SF_TRIGGER_HURT_NO_CLIENTS      8           // Spawnflag that makes trigger_push spawn turned OFF
+#define SF_TRIGGER_HURT_CLIENTONLYFIRE	16          // Trigger hurt will only fire its target if it is hurting a client
+#define SF_TRIGGER_HURT_CLIENTONLYTOUCH 32          // Only clients may touch this trigger
+
+// trigger_auto
+#define SF_AUTO_FIREONCE                0x0001
+
+// trigger_relay
+#define SF_RELAY_FIREONCE               0x0001
+
+// multi_manager
+#define SF_MULTIMAN_CLONE               0x80000000
+#define SF_MULTIMAN_THREAD              0x00000001
+
+// env_render - Flags to indicate masking off various render parameters that are normally copied to the targets
+#define SF_RENDER_MASKFX                (1<<0)
+#define SF_RENDER_MASKAMT               (1<<1)
+#define SF_RENDER_MASKMODE              (1<<2)
+#define SF_RENDER_MASKCOLOR             (1<<3)
+
+// trigger_changelevel
+#define SF_CHANGELEVEL_USEONLY          0x0002
+
+// trigger_endsection
+#define SF_ENDSECTION_USEONLY           0x0001
+
+// trigger_camera
+#define SF_CAMERA_PLAYER_POSITION       1
+#define SF_CAMERA_PLAYER_TARGET         2
+#define SF_CAMERA_PLAYER_TAKECONTROL    4
+
+// func_rotating
+#define SF_BRUSH_ROTATE_Y_AXIS          0
+#define SF_BRUSH_ROTATE_INSTANT         1
+#define SF_BRUSH_ROTATE_BACKWARDS       2
+#define SF_BRUSH_ROTATE_Z_AXIS          4
+#define SF_BRUSH_ROTATE_X_AXIS          8
+#define SF_PENDULUM_AUTO_RETURN         16
+#define	SF_PENDULUM_PASSABLE            32
+#define SF_BRUSH_ROTATE_SMALLRADIUS     128
+#define SF_BRUSH_ROTATE_MEDIUMRADIUS    256
+#define SF_BRUSH_ROTATE_LARGERADIUS     512
+
+// triggers
+#define	SF_TRIGGER_ALLOWMONSTERS        1           // Monsters allowed to fire this trigger
+#define	SF_TRIGGER_NOCLIENTS            2           // Players not allowed to fire this trigger
+#define SF_TRIGGER_PUSHABLES            4           // Only pushables can fire this trigger
+
+#define SF_TRIG_PUSH_ONCE               1
+// func_breakable
+#define SF_BREAK_TRIGGER_ONLY           1           // May only be broken by trigger
+#define	SF_BREAK_TOUCH                  2           // Can be 'crashed through' by running player (plate glass)
+#define SF_BREAK_PRESSURE               4           // Can be broken by a player standing on it
+#define SF_BREAK_CROWBAR                256         // Instant break if hit with crowbar
+
+// func_pushable (it's also func_breakable, so don't collide with those flags)
+#define SF_PUSH_BREAKABLE               128
+
+// light_spawn
+#define SF_LIGHT_START_OFF              1
+#define SPAWNFLAG_NOMESSAGE             1
+#define SPAWNFLAG_NOTOUCH               1
+#define SPAWNFLAG_DROIDONLY             4
+#define SPAWNFLAG_USEONLY               1           // Can't be touched, must be used (buttons)
+
+// Monster Spawnflags
+#define	SF_MONSTER_WAIT_TILL_SEEN       1           // Spawnflag that makes monsters wait until player can see them before attacking
+#define	SF_MONSTER_GAG                  2           // No idle noises from this monster
+#define SF_MONSTER_HITMONSTERCLIP       4
+#define SF_MONSTER_PRISONER             16          // Monster won't attack anyone, no one will attacke him
+#define	SF_MONSTER_WAIT_FOR_SCRIPT      128         // Spawnflag that makes monsters wait to check for attacking until the script is done or they've been attacked
+#define SF_MONSTER_PREDISASTER          256         // This is a predisaster scientist or barney; influences how they speak
+#define SF_MONSTER_FADECORPSE           512         // Fade out corpse after death
+#define SF_MONSTER_FALL_TO_GROUND       0x80000000
+#define SF_MONSTER_TURRET_AUTOACTIVATE  32
+#define SF_MONSTER_TURRET_STARTINACTIVE 64
+#define SF_MONSTER_WAIT_UNTIL_PROVOKED  64          // Don't attack the player unless provoked
+
+// info_decal
+#define SF_DECAL_NOTINDEATHMATCH        2048
+
+// worldspawn
+#define SF_WORLD_DARK                   0x0001      // Fade from black at startup
+#define SF_WORLD_TITLE                  0x0002      // Display game title at startup
+#define SF_WORLD_FORCETEAM              0x0004      // Force teams
+
+// Set this bit on guns and stuff that should never respawn
+#define SF_NORESPAWN                    (1<<30)