diff --git a/dlls/arrayx/Array.cpp b/dlls/arrayx/Array.cpp
new file mode 100644
index 00000000..50d83f1e
--- /dev/null
+++ b/dlls/arrayx/Array.cpp
@@ -0,0 +1,35 @@
+#include "amxxmodule.h"
+#include "ComboArray.h"
+
+extern AMX_NATIVE_INFO bintrie_exports[];
+extern AMX_NATIVE_INFO bintrie_usage_exports[];
+extern ComboArray MasterTrie;
+
+extern AMX_NATIVE_INFO list_exports[];
+extern AMX_NATIVE_INFO list_creation_exports[];
+extern ComboArray MasterList;
+
+extern AMX_NATIVE_INFO map_exports[];
+extern AMX_NATIVE_INFO map_creation_exports[];
+extern ComboArray MasterMap;
+
+
+void OnAmxxAttach( void )
+{
+ MF_AddNatives(bintrie_exports);
+ MF_AddNatives(bintrie_usage_exports);
+
+ MF_AddNatives(list_exports);
+ MF_AddNatives(list_creation_exports);
+
+ MF_AddNatives(map_exports);
+ MF_AddNatives(map_creation_exports);
+
+}
+
+void OnAmxxDetach( void )
+{
+ MasterTrie.Clear();
+ MasterList.Clear();
+ MasterMap.Clear();
+}
\ No newline at end of file
diff --git a/dlls/arrayx/Array.dsp b/dlls/arrayx/Array.dsp
new file mode 100644
index 00000000..177627f0
--- /dev/null
+++ b/dlls/arrayx/Array.dsp
@@ -0,0 +1,237 @@
+# Microsoft Developer Studio Project File - Name="Array" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=Array - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "Array.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "Array.mak" CFG="Array - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Array - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "Array - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Array - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "ARRAY_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "ARRAY_EXPORTS" /FR /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+
+!ELSEIF "$(CFG)" == "Array - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "ARRAY_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "ARRAY_EXPORTS" /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "Array - Win32 Release"
+# Name "Array - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\Array.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\BinTrieNatives.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Capsule.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\CArray.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\CBinTrie.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\CKeytable.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\JudyExtra.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ListNatives.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MapNatives.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\BinTrieNativeFunctions.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Capsule.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\CArray.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\CBaseList.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\CBaseMap.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\CBinTrie.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\CHashtable.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\CKeytable.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ComboArray.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ComboTable.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\GenericNatives.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\JudyIncludes.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\MapNativeFunctions.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# Begin Source File
+
+SOURCE=.\amxxmodule.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\amxxmodule.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Judy.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\JudyEx.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\JudyExtra.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\JudyVar.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\JudyVec.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ListNativeFunctions.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\moduleconfig.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\NativeIncludes.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\osdefs.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Judy.lib
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/dlls/arrayx/Array.dsw b/dlls/arrayx/Array.dsw
new file mode 100644
index 00000000..b670e501
--- /dev/null
+++ b/dlls/arrayx/Array.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Array"=".\Array.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/dlls/arrayx/Array.ncb b/dlls/arrayx/Array.ncb
new file mode 100644
index 00000000..fc670dbf
Binary files /dev/null and b/dlls/arrayx/Array.ncb differ
diff --git a/dlls/arrayx/Array.opt b/dlls/arrayx/Array.opt
new file mode 100644
index 00000000..8fd4bb98
Binary files /dev/null and b/dlls/arrayx/Array.opt differ
diff --git a/dlls/arrayx/Array.plg b/dlls/arrayx/Array.plg
new file mode 100644
index 00000000..e854a47d
--- /dev/null
+++ b/dlls/arrayx/Array.plg
@@ -0,0 +1,96 @@
+
+
+
+Build Log
+
+--------------------Configuration: Array - Win32 Release--------------------
+
+Command Lines
+Creating temporary file "C:\DOCUME~1\Edward\LOCALS~1\Temp\RSPC49.tmp" with contents
+[
+/nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "ARRAY_EXPORTS" /FR"Release/" /Fp"Release/Array.pch" /YX /Fo"Release/" /Fd"Release/" /FD /c
+"C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\Array.cpp"
+"C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\BinTrieNatives.cpp"
+"C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\Capsule.cpp"
+"C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\CArray.cpp"
+"C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\CBinTrie.cpp"
+"C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\CKeytable.cpp"
+"C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp"
+"C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\ListNatives.cpp"
+"C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\MapNatives.cpp"
+"C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\amxxmodule.cpp"
+]
+Creating command line "cl.exe @C:\DOCUME~1\Edward\LOCALS~1\Temp\RSPC49.tmp"
+Creating temporary file "C:\DOCUME~1\Edward\LOCALS~1\Temp\RSPC4A.tmp" with contents
+[
+kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /pdb:"Release/Array.pdb" /machine:I386 /out:"Release/Array.dll" /implib:"Release/Array.lib"
+".\Release\Array.obj"
+".\Release\BinTrieNatives.obj"
+".\Release\Capsule.obj"
+".\Release\CArray.obj"
+".\Release\CBinTrie.obj"
+".\Release\CKeytable.obj"
+".\Release\JudyExtra.obj"
+".\Release\ListNatives.obj"
+".\Release\MapNatives.obj"
+".\Release\amxxmodule.obj"
+".\Judy.lib"
+]
+Creating command line "link.exe @C:\DOCUME~1\Edward\LOCALS~1\Temp\RSPC4A.tmp"
+Output Window
+Compiling...
+Array.cpp
+BinTrieNatives.cpp
+Capsule.cpp
+CArray.cpp
+CBinTrie.cpp
+CKeytable.cpp
+JudyExtra.cpp
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(8) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(15) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(40) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(75) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(80) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(83) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(103) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(107) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(110) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(133) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(147) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(152) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(155) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(170) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(178) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(186) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(189) : warning C4101: 'e' : unreferenced local variable
+C:\Documents and Settings\Edward\Desktop\module\Judy Test\Array\JudyExtra.cpp(217) : warning C4101: 'e' : unreferenced local variable
+ListNatives.cpp
+MapNatives.cpp
+amxxmodule.cpp
+Linking...
+ Creating library Release/Array.lib and object Release/Array.exp
+LINK : warning LNK4098: defaultlib "LIBC" conflicts with use of other libs; use /NODEFAULTLIB:library
+Creating temporary file "C:\DOCUME~1\Edward\LOCALS~1\Temp\RSPC4E.tmp" with contents
+[
+/nologo /o"Release/Array.bsc"
+".\Release\Array.sbr"
+".\Release\BinTrieNatives.sbr"
+".\Release\Capsule.sbr"
+".\Release\CArray.sbr"
+".\Release\CBinTrie.sbr"
+".\Release\CKeytable.sbr"
+".\Release\JudyExtra.sbr"
+".\Release\ListNatives.sbr"
+".\Release\MapNatives.sbr"
+".\Release\amxxmodule.sbr"]
+Creating command line "bscmake.exe @C:\DOCUME~1\Edward\LOCALS~1\Temp\RSPC4E.tmp"
+Creating browse info file...
+Output Window
+
+
+
+Results
+Array.dll - 0 error(s), 19 warning(s)
+
+
+
diff --git a/dlls/arrayx/BinTrieNativeFunctions.h b/dlls/arrayx/BinTrieNativeFunctions.h
new file mode 100644
index 00000000..03beacea
--- /dev/null
+++ b/dlls/arrayx/BinTrieNativeFunctions.h
@@ -0,0 +1,79 @@
+#ifndef _bintrie_NATIVE_FUNC_INC_H
+#define _bintrie_NATIVE_FUNC_INC_H
+
+#define JUDY_GLUE_FUNC( x , y ) x ## y
+
+#define JUDY_GLUE_STR( x, y ) #x#y
+
+#define JUDY_MASTER_EDIT_FUNCTIONS
+#define JUDY_MASTER_CLEAR_FUNC JUDY_GLUE_FUNC( bintrie , _clear )
+#define JUDY_MASTER_CLEAR_STR JUDY_GLUE_STR ( bintrie , _clear )
+
+#define JUDY_MASTER_DELETE_FUNC JUDY_GLUE_FUNC( bintrie , _delete )
+#define JUDY_MASTER_DELETE_STR JUDY_GLUE_STR ( bintrie , _delete )
+
+#define JUDY_MASTER_IO_FUNCTIONS
+
+#define JUDY_MASTER_SAVE_FUNC JUDY_GLUE_FUNC( bintrie , _save )
+#define JUDY_MASTER_SAVE_STR JUDY_GLUE_STR ( bintrie , _save )
+#define JUDY_SAVE_FUNC(bin,file) JudySaveBinTrie(bin , file )
+
+#define JUDY_MASTER_LOAD_FUNC JUDY_GLUE_FUNC( bintrie , _load )
+#define JUDY_MASTER_LOAD_STR JUDY_GLUE_STR ( bintrie , _load )
+#define JUDY_LOAD_FUNC(bin, file) JudyLoadBinTrie(bin , file )
+
+#define JUDY_MASTER_AMOUNT_FUNCTIONS
+#define JUDY_MASTER_COUNT_FUNC JUDY_GLUE_FUNC( bintrie , _count )
+#define JUDY_MASTER_COUNT_STR JUDY_GLUE_STR ( bintrie , _count )
+
+#define JUDY_MASTER_BYCOUNT_FUNC JUDY_GLUE_FUNC( bintrie , _bycount )
+#define JUDY_MASTER_BYCOUNT_STR JUDY_GLUE_STR ( bintrie , _bycount )
+
+#define JUDY_SLAVE_AMOUNT_FUNCTIONS
+
+#define JUDY_SLAVE_COUNT_FUNC JUDY_GLUE_FUNC( bintrie , _size )
+#define JUDY_SLAVE_COUNT_STR JUDY_GLUE_STR ( bintrie , _size )
+
+#define JUDY_SLAVE_BYCOUNT_FUNC JUDY_GLUE_FUNC( bintrie , _get_nth )
+#define JUDY_SLAVE_BYCOUNT_STR JUDY_GLUE_STR ( bintrie , _get_nth )
+
+#define JUDY_SLAVE_EDIT_FUNCTIONS
+
+#define JUDY_SLAVE_MEMORY_FUNC JUDY_GLUE_FUNC( bintrie , _memory )
+#define JUDY_SLAVE_MEMORY_STR JUDY_GLUE_STR ( bintrie , _memory )
+
+#define JUDY_SLAVE_ISFILLED_FUNC JUDY_GLUE_FUNC( bintrie , _isfilled )
+#define JUDY_SLAVE_ISFILLED_STR JUDY_GLUE_STR ( bintrie , _isfilled )
+
+#define JUDY_SLAVE_ISEMPTY_FUNC JUDY_GLUE_FUNC( bintrie , _isempty )
+#define JUDY_SLAVE_ISEMPTY_STR JUDY_GLUE_STR ( bintrie , _isempty )
+
+#define JUDY_SLAVE_REMOVE_FUNC JUDY_GLUE_FUNC( bintrie , _remove )
+#define JUDY_SLAVE_REMOVE_STR JUDY_GLUE_STR ( bintrie , _remove )
+
+#define JUDY_SLAVE_SEARCH_FUNCTIONS
+#define JUDY_SLAVE_FIRST_FUNC JUDY_GLUE_FUNC( bintrie , _first )
+#define JUDY_SLAVE_LAST_FUNC JUDY_GLUE_FUNC( bintrie , _last )
+
+#define JUDY_SLAVE_FIRST_STR JUDY_GLUE_STR ( bintrie , _first )
+#define JUDY_SLAVE_LAST_STR JUDY_GLUE_STR ( bintrie , _last )
+
+#define JUDY_SLAVE_NEXT_FUNC JUDY_GLUE_FUNC( bintrie , _next )
+#define JUDY_SLAVE_PREV_FUNC JUDY_GLUE_FUNC( bintrie , _prev )
+
+#define JUDY_SLAVE_NEXT_STR JUDY_GLUE_STR ( bintrie , _next )
+#define JUDY_SLAVE_PREV_STR JUDY_GLUE_STR ( bintrie , _prev )
+
+#define JUDY_SLAVE_SEARCH_EMPTY_FUNCTIONS
+#define JUDY_SLAVE_FIRSTEMPTY_FUNC JUDY_GLUE_FUNC( bintrie , _firstempty )
+#define JUDY_SLAVE_LASTEMPTY_FUNC JUDY_GLUE_FUNC( bintrie , _lastempty )
+
+#define JUDY_SLAVE_FIRSTEMPTY_STR JUDY_GLUE_STR ( bintrie , _firstempty )
+#define JUDY_SLAVE_LASTEMPTY_STR JUDY_GLUE_STR ( bintrie , _lastempty )
+
+#define JUDY_SLAVE_NEXTEMPTY_FUNC JUDY_GLUE_FUNC( bintrie , _nextempty )
+#define JUDY_SLAVE_PREVEMPTY_FUNC JUDY_GLUE_FUNC( bintrie , _prevempty )
+
+#define JUDY_SLAVE_NEXTEMPTY_STR JUDY_GLUE_STR ( bintrie , _nextempty )
+#define JUDY_SLAVE_PREVEMPTY_STR JUDY_GLUE_STR ( bintrie , _prevempty )
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/BinTrieNatives.cpp b/dlls/arrayx/BinTrieNatives.cpp
new file mode 100644
index 00000000..8224dd49
--- /dev/null
+++ b/dlls/arrayx/BinTrieNatives.cpp
@@ -0,0 +1,57 @@
+#include "CBinTrie.h"
+
+#define KEY_TYPE cell
+#define DYNAMIC_UNIT_TYPE BinTrie
+#define STORAGE_TYPE cell
+#define MASTER_NAME MasterTrie
+#define EXPORT_NAME bintrie_exports
+
+#define SEARCH_ERROR_OFFSET 0
+
+#define GET_KEY(params, num) params[num]
+#define SET_KEY(stuff, parameter) stuff
+
+#include "BinTrieNativeFunctions.h"
+#include "NativeIncludes.h"
+
+static cell AMX_NATIVE_CALL bintrie_create(AMX *amx,cell *params)
+{
+ DTYPE* Unit;
+ M_ITYPE Index = params[1];
+
+ JUDY_CREATE_INDEX(MNAME,Unit,BinTrie,Index);
+ return Index;
+}
+
+static cell AMX_NATIVE_CALL bintrie_set(AMX *amx,cell *params)
+{
+ DTYPE* Unit = NULL;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ bool Value = (params[3] != NULL);
+
+ try { return Unit->Set(Indice, Value ); }
+ JUDY_ERROR_CATCH("Judy Error: (No error possible) - Slave Set Function ");
+}
+
+static cell AMX_NATIVE_CALL bintrie_get(AMX *amx,cell *params)
+{
+ DTYPE* Unit = NULL;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+
+ try { return Unit->Get(Indice ); }
+ JUDY_ERROR_CATCH("Judy Error: (No error possible) - Slave Get Function ");
+}
+
+
+AMX_NATIVE_INFO bintrie_usage_exports[] =
+{
+ { "bintrie_create", bintrie_create },
+ { "bintrie_set", bintrie_set },
+ { "bintrie_get", bintrie_get },
+
+ { NULL, NULL }
+};
\ No newline at end of file
diff --git a/dlls/arrayx/CArray.cpp b/dlls/arrayx/CArray.cpp
new file mode 100644
index 00000000..2285e4d3
--- /dev/null
+++ b/dlls/arrayx/CArray.cpp
@@ -0,0 +1,87 @@
+#include "CArray.h"
+
+void Array::ThrowSearchError(char* type)
+{
+ char value[50];
+ sprintf(value,"Function attempted to search %s: Judy returned NULL value", type);
+
+ throw JudyEx(value,false);
+}
+
+void Array::ThrowIndexError( cell index, bool disable_check )
+{
+ if(disable_check == true) return;
+
+ char error[50];
+ sprintf(error,"Index %i is not set.",index);
+
+ throw JudyEx(error,true);
+}
+
+cell Array::First( cell Start)
+{
+ PPvoid_t success = JudyLFirst(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:First");
+
+ return Start;
+}
+
+cell Array::FirstEmpty( cell Start)
+{
+ cell success = JudyLFirstEmpty(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:FirstEmpty");
+ return Start;
+}
+
+cell Array::Next( cell Start)
+{
+ PPvoid_t success = JudyLNext(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:Next");
+
+ return Start;
+}
+
+cell Array::NextEmpty( cell Start)
+{
+ cell success = JudyLNextEmpty(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:NextEmpty");
+ return Start;
+}
+
+cell Array::Prev( cell Start)
+{
+ PPvoid_t success = JudyLPrev(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:Prev");
+
+ return Start;
+}
+
+cell Array::PrevEmpty( cell Start)
+{
+ cell success = JudyLPrevEmpty(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:PrevEmpty");
+ return Start;
+}
+
+cell Array::Last( cell Start)
+{
+ PPvoid_t success = JudyLLast(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:Last");
+
+ return Start;
+}
+
+cell Array::LastEmpty( cell Start)
+{
+ cell success = JudyLLastEmpty(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:LastEmpty");
+ return Start;
+}
+
+cell Array::ByCount(cell n, cell Start)
+{
+ PPvoid_t success = JudyLByCount(Table, n, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:Nth");
+
+ return Start;
+}
\ No newline at end of file
diff --git a/dlls/arrayx/CArray.h b/dlls/arrayx/CArray.h
new file mode 100644
index 00000000..8af5881c
--- /dev/null
+++ b/dlls/arrayx/CArray.h
@@ -0,0 +1,73 @@
+#ifndef _ARRAYCLASS_H
+#define _ARRAYCLASS_H
+
+#include "JudyIncludes.h"
+#include "CBaseList.h"
+#include "JudyExtra.h"
+//#include
+
+class Array: public CBaseList
+{
+private:
+ Pvoid_t Table;
+
+ void ThrowIndexError( cell index, bool disable_check = false );
+ void ThrowSearchError(char* msg);
+
+public:
+ Array() { Table = NULL; }
+ ~Array() { Clear(); }
+
+ Word_t Clear() { JudyClearList(this); return JudyLFreeArray(&Table, PJE0); }
+ Word_t MemoryUsed() { return JudyLMemUsed(Table); }
+
+ int Delete(cell Key) { delete Get(Key,true); return JudyLDel(&Table, Key, PJE0 ); }
+
+ void Set(cell Index, Pvoid_t value, bool disable_check)
+ {
+ PPvoid_t PValue = JudyLIns(&Table, Index,PJE0);
+ *PValue = value;
+ }
+
+ Pvoid_t Get(cell Index, bool disable_check = false)
+ {
+ PPvoid_t PValue = JudyLGet(Table, Index, PJE0);
+ if(PValue == NULL) { ThrowIndexError(Index, disable_check); return NULL; }
+
+ return *PValue;
+ }
+
+ template
+ void Set(cell Index, Type value)
+ {
+ PPvoid_t PValue = JudyLIns(&Table, Index,PJE0);
+ *PValue = reinterpret_cast(value);
+ }
+
+ template
+ Type Get(cell Index, Type example, bool disable_check = false)
+ {
+ PPvoid_t PValue = JudyLGet(Table, Index, PJE0);
+ if(PValue == NULL) { ThrowIndexError(Index, disable_check); return (Type)NULL; }
+
+ return (Type)(*PValue);
+ }
+
+ cell First(cell Start = 0);
+ cell Next(cell Start = 0);
+ cell Prev(cell Start = -1);
+ cell Last(cell Start = -1);
+
+ cell FirstEmpty(cell Start = 0);
+ cell NextEmpty(cell Start = 0);
+ cell PrevEmpty(cell Start = -1);
+ cell LastEmpty(cell Start = -1);
+
+ cell ByCount(cell n, cell Start = 0);
+ cell Count(cell Start = 0, cell Stop = -1) { return JudyLCount(Table, Start, Stop, PJE0); }
+
+ bool IsFilled(cell Index) { return ( (Get(Index, true ) != NULL) ? true : false); }
+ bool IsEmpty(cell Index) { return ( (Get(Index, true ) == NULL) ? true : false); }
+};
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/CBaseList.h b/dlls/arrayx/CBaseList.h
new file mode 100644
index 00000000..a9ce4646
--- /dev/null
+++ b/dlls/arrayx/CBaseList.h
@@ -0,0 +1,35 @@
+#ifndef _BASE_ARRAYCLASS_H
+#define _BASE_ARRAYCLASS_H
+
+#include "JudyIncludes.h"
+
+class CBaseList
+{
+public:
+ virtual Word_t Clear() =0;
+ virtual Word_t MemoryUsed() =0;
+
+ virtual int Delete(cell Key) =0;
+
+ virtual void Set(cell Index, Pvoid_t value, bool disable_check = false) =0;
+
+ virtual Pvoid_t Get(cell Index, bool disable_check = false) =0;
+
+ virtual cell First(cell Start = 0) =0;
+ virtual cell Next(cell Start = 0) =0;
+ virtual cell Prev(cell Start = -1) =0;
+ virtual cell Last(cell Start = -1) =0;
+
+ virtual cell FirstEmpty(cell Start = 0) =0;
+ virtual cell NextEmpty(cell Start = 0) =0;
+ virtual cell PrevEmpty(cell Start = -1) =0;
+ virtual cell LastEmpty(cell Start = -1) =0;
+
+ virtual cell ByCount(cell n, cell Start = 0) =0;
+ virtual cell Count(cell Start = 0, cell Stop = -1) =0;
+
+ virtual bool IsFilled(cell Index) =0;
+ virtual bool IsEmpty(cell Index) =0;
+};
+
+#endif
diff --git a/dlls/arrayx/CBaseMap.h b/dlls/arrayx/CBaseMap.h
new file mode 100644
index 00000000..ef0b6a5c
--- /dev/null
+++ b/dlls/arrayx/CBaseMap.h
@@ -0,0 +1,28 @@
+#ifndef _BASE_MAPCLASS_H
+#define _BASE_MAPCLASS_H
+
+#include "JudyIncludes.h"
+
+class CBaseMap
+{
+public:
+ virtual Word_t Clear() =0;
+ virtual Word_t MemoryUsed() =0;
+
+ virtual int Delete(char* Key) =0;
+
+ virtual void Set(char* Index, Pvoid_t value, bool disable_check = false) =0;
+
+ virtual Pvoid_t Get(char* Index, bool disable_check = false) =0;
+
+ virtual char* First(char* Start = "") =0;
+ virtual char* Next(char* Start) =0;
+ virtual char* Prev(char* Start) =0;
+ virtual char* Last(char* Start) =0;
+
+ virtual bool IsFilled(char* Index) =0;
+ virtual bool IsEmpty(char* Index) =0;
+};
+
+#endif
+
diff --git a/dlls/arrayx/CBinTrie.cpp b/dlls/arrayx/CBinTrie.cpp
new file mode 100644
index 00000000..33e712c8
--- /dev/null
+++ b/dlls/arrayx/CBinTrie.cpp
@@ -0,0 +1,76 @@
+#include "CBinTrie.h"
+
+void BinTrie::ThrowSearchError(char* type)
+{
+ char value[50];
+ sprintf(value,"Function attempted to search %s: Judy returned NULL value", type);
+
+ throw JudyEx (value,false);
+}
+
+cell BinTrie::First( cell Start)
+{
+ cell success = Judy1First(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:First");
+ return Start;
+}
+
+cell BinTrie::FirstEmpty( cell Start)
+{
+ cell success = Judy1FirstEmpty(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:FirstEmpty");
+ return Start;
+}
+
+cell BinTrie::Next( cell Start)
+{
+ cell success = Judy1Next(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:Next");
+
+ return Start;
+}
+
+cell BinTrie::NextEmpty( cell Start)
+{
+ cell success = Judy1NextEmpty(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:NextEmpty");
+ return Start;
+}
+
+cell BinTrie::Prev( cell Start)
+{
+ cell success = Judy1Prev(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:Prev");
+
+ return Start;
+}
+
+cell BinTrie::PrevEmpty( cell Start)
+{
+ cell success = Judy1PrevEmpty(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:PrevEmpty");
+ return Start;
+}
+
+cell BinTrie::Last( cell Start)
+{
+ cell success = Judy1Last(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:Last");
+
+ return Start;
+}
+
+cell BinTrie::LastEmpty( cell Start)
+{
+ cell success = Judy1LastEmpty(Table, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:LastEmpty");
+ return Start;
+}
+
+cell BinTrie::ByCount(cell n, cell Start)
+{
+ cell success = Judy1ByCount(Table, n, reinterpret_cast(&Start), PJE0);
+ if (success == NULL) ThrowSearchError("Type:Nth");
+
+ return Start;
+}
\ No newline at end of file
diff --git a/dlls/arrayx/CBinTrie.h b/dlls/arrayx/CBinTrie.h
new file mode 100644
index 00000000..a1d9e3fc
--- /dev/null
+++ b/dlls/arrayx/CBinTrie.h
@@ -0,0 +1,52 @@
+#ifndef _BINTRIECLASS_H
+#define _BINTRIECLASS_H
+
+#include "JudyIncludes.h"
+//#include
+
+class BinTrie
+{
+private:
+ Pvoid_t Table;
+
+ void ThrowSearchError(char* msg);
+
+public:
+ BinTrie() { Table = NULL; }
+ ~BinTrie() { Judy1FreeArray(&Table, PJE0); }
+
+ Word_t Clear() { return Judy1FreeArray(&Table, PJE0); }
+ Word_t MemoryUsed() { return Judy1MemUsed(Table); }
+
+ cell Delete(cell Key) { return Judy1Unset(&Table, Key, PJE0 ); }
+
+ cell Set(cell Index, bool val)
+ {
+ if(val == false) return Delete(Index);
+ else return Judy1Set(&Table, Index,PJE0);
+ }
+
+ cell Get(cell Index)
+ {
+ cell PValue = Judy1Test(Table, Index, PJE0);
+ return PValue;
+ }
+
+ cell First(cell Start = 0);
+ cell Next(cell Start = 0);
+ cell Prev(cell Start = -1);
+ cell Last(cell Start = -1);
+
+ cell FirstEmpty(cell Start = 0);
+ cell NextEmpty(cell Start = 0);
+ cell PrevEmpty(cell Start = -1);
+ cell LastEmpty(cell Start = -1);
+
+ cell ByCount(cell n, cell Start);
+ cell Count(cell Start = 0, cell Stop = -1) { return Judy1Count(Table, Start, Stop, PJE0); }
+
+ bool IsFilled(cell Index) { return ( (Get(Index )) ? true : false); }
+ bool IsEmpty(cell Index) { return ( (Get(Index )) ? true : false); }
+};
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/CHashtable.h b/dlls/arrayx/CHashtable.h
new file mode 100644
index 00000000..5fee0a39
--- /dev/null
+++ b/dlls/arrayx/CHashtable.h
@@ -0,0 +1,81 @@
+#ifndef _HASHCLASS_INCLUDED
+#define _HASHCLASS_INCLUDED
+
+#include "JudyIncludes.h"
+#include "CBaseMap.h"
+//#include
+
+class Hashtable: public CBaseMap
+{
+private:
+ Pvoid_t Table;
+
+public:
+ Hashtable() { Table = NULL; }
+ ~Hashtable() { Clear(); }
+
+ Word_t Clear() { return JudyHSFreeArray(&Table, PJE0); }
+ Word_t MemoryUsed() { return JudyLMemUsed(Table); }
+
+ int Delete(char* Key) { delete Get(Key,true); return JudyHSDel(&Table, Key, strlen(Key), PJE0 ); }
+
+ void Set(char* Index, Pvoid_t value, bool disable_check)
+ {
+ int Len = strlen(Index) + 1;
+ PPvoid_t PValue = JudyHSIns(&Table, Index, Len, PJE0);
+ *PValue = value;
+ }
+
+ Pvoid_t Get(char* Index, bool disable_check = false)
+ {
+ PPvoid_t PValue = JudyHSGet(Table, Index, strlen(Index)+1);
+ if(PValue == NULL) { ThrowIndexError(Index, disable_check); return NULL; }
+
+ return *PValue;
+ }
+
+ template
+ void Set(char* Index, Type value)
+ {
+ int Len = strlen(Index) + 1;
+ PPvoid_t PValue = JudyHSIns(&Table, Index, Len, PJE0);
+ *PValue = reinterpret_cast(value);
+ }
+
+ template
+ Type Get(char* Index, Type example, bool disable_check = false)
+ {
+ PPvoid_t PValue = JudyHSGet(Table, Index, strlen(Index)+1);
+ if(PValue == NULL) { ThrowIndexError(Index, disable_check); return (Type)NULL; }
+
+ return (Type)(*PValue);
+ }
+
+ char* First( char* Start = "") { ThrowSearchError(); return (char*)NULL; }
+ char* Next( char* Start = "") { ThrowSearchError(); return (char*)NULL; }
+ char* Prev( char* Start) { ThrowSearchError(); return (char*)NULL; }
+ char* Last( char* Start) { ThrowSearchError(); return (char*)NULL; }
+
+ bool IsFilled(char* Index) { return ( (Get(Index,(PPvoid_t)(NULL), true ) != NULL) ? true : false);}
+ bool IsEmpty(char* Index) { return ( (Get(Index,(PPvoid_t)(NULL), true ) == NULL) ? true : false);}
+
+protected:
+ void ThrowIndexError( char* index, bool disable_check = false )
+ {
+ if(disable_check == true) return;
+
+ char value[100];
+ sprintf(value,"Function attempted to read non existant index %s", index );
+
+ throw JudyEx(value, true);
+ }
+ void ThrowSearchError( void )
+ {
+ char value[50];
+ sprintf(value,"Function attempted to search HashTable!: Invalid action!");
+
+ throw JudyEx(value,true);
+ }
+};
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/CKeytable.cpp b/dlls/arrayx/CKeytable.cpp
new file mode 100644
index 00000000..43f70c17
--- /dev/null
+++ b/dlls/arrayx/CKeytable.cpp
@@ -0,0 +1,66 @@
+#include "CKeytable.h"
+
+void Keytable::ThrowIndexError( char* index, bool disable_check = false )
+{
+ if(disable_check == true) return;
+
+ char error[50];
+ sprintf(error,"Index %s is not set.",index);
+
+ throw JudyEx(error,true);
+}
+
+void Keytable::ThrowSearchError(char* type)
+{
+ char value[50];
+ sprintf(value,"Function attempted to search %s: Judy returned NULL value", type);
+
+ throw JudyEx(value,false);
+}
+
+char* Keytable::First( char* Start)
+{
+ PPvoid_t index = JudySLFirst(Table, Start, PJE0);
+ if (index == NULL)
+ {
+ sprintf(Start,"dne");
+ ThrowSearchError("Type:First");
+ }
+
+ return Start;
+}
+
+char* Keytable::Next( char* Start)
+{
+ PPvoid_t index = JudySLNext(Table, Start, PJE0);
+ if (index == NULL)
+ {
+ sprintf(Start,"dne");
+ ThrowSearchError("Type:Next");
+ }
+ return Start;
+}
+
+char* Keytable::Prev( char* Start)
+{
+ PPvoid_t index = JudySLPrev(Table, Start, PJE0);
+ if (index == NULL)
+ {
+ sprintf(Start,"dne");
+ ThrowSearchError("Type:Prev");
+ }
+
+ return Start;
+}
+
+char* Keytable::Last( char* Start)
+{
+ PPvoid_t index = JudySLLast(Table, Start, PJE0);
+ if (index == NULL)
+ {
+ sprintf(Start,"dne");
+ ThrowSearchError("Type:Last");
+ }
+
+ return Start;
+}
\ No newline at end of file
diff --git a/dlls/arrayx/CKeytable.h b/dlls/arrayx/CKeytable.h
new file mode 100644
index 00000000..ba649561
--- /dev/null
+++ b/dlls/arrayx/CKeytable.h
@@ -0,0 +1,65 @@
+#ifndef _KEYCLASS_INCLUDED
+#define _KEYCLASS_INCLUDED
+
+#include "JudyIncludes.h"
+#include "CBaseMap.h"
+#include "JudyExtra.h"
+//#include
+
+class Keytable: public CBaseMap
+{
+private:
+ Pvoid_t Table;
+
+ void ThrowSearchError(char* type);
+ void ThrowIndexError( char* index, bool disable_check);
+
+public:
+ Keytable() { Table = NULL; }
+ ~Keytable() { Clear(); }
+
+ Word_t Clear() { JudyClearMap(this); return JudySLFreeArray(&Table, PJE0); }
+ Word_t MemoryUsed() { return JudyLMemUsed(Table); }
+
+ int Delete(char* Key) { delete Get(Key,true); return JudySLDel(&Table, Key, PJE0 ); }
+
+ void Set(char* Index, Pvoid_t value, bool disable_check)
+ {
+ PPvoid_t PValue = JudySLIns(&Table, Index,PJE0);
+ *PValue = value;
+ }
+
+ Pvoid_t Get(char* Index, bool disable_check = false)
+ {
+ PPvoid_t PValue = JudySLGet(Table, Index, PJE0);
+ if(PValue == NULL) { ThrowIndexError(Index, disable_check); return NULL; }
+
+ return *PValue;
+ }
+
+ template
+ void Set(char* Index, Type value)
+ {
+ PPvoid_t PValue = JudySLIns(&Table, Index,PJE0);
+ *PValue = reinterpret_cast(value);
+ }
+
+ template
+ Type Get(char* Index, Type example, bool disable_check = false)
+ {
+ PPvoid_t PValue = JudySLGet(Table, Index, PJE0);
+ if(PValue == NULL) { ThrowIndexError(Index, disable_check); return (Type)NULL; }
+
+ return (Type)*PValue;
+ }
+
+ char* First(char* Start = "");
+ char* Next(char* Start = "");
+ char* Prev(char* Start = "");
+ char* Last(char* Start = "");
+
+ bool IsFilled(char* Index) { return ( (Get(Index,(PPvoid_t)(NULL), true ) != NULL) ? true : false); }
+ bool IsEmpty(char* Index) { return ( (Get(Index,(PPvoid_t)(NULL), true ) == NULL) ? true : false); }
+};
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/Capsule.cpp b/dlls/arrayx/Capsule.cpp
new file mode 100644
index 00000000..c58eff52
--- /dev/null
+++ b/dlls/arrayx/Capsule.cpp
@@ -0,0 +1,261 @@
+#include "Capsule.h"
+
+const char* capsule_types[] =
+{
+ "-NO VALUE-",
+ "BOOLEAN",
+ "INTEGER",
+ "FLOAT",
+ "VECTOR",
+ "STRING"
+};
+
+void Capsule::ThrowTypeError(cell get_type)
+{
+ char ValStr[15];
+ GetAsStr(ValStr);
+
+ char value[100];
+ sprintf(value,"Function attempted to read NON-%s value, actual type is: %s, actual value is: %s", capsule_types[get_type], capsule_types[type], ValStr );
+
+ throw JudyEx(value, true);
+}
+
+bool Capsule::CheckEmpty(bool clear)
+{
+ bool empty = ( data == NULL );
+
+ if(empty != true && clear == true) Clear();
+ return empty;
+}
+
+void Capsule::Clear()
+{
+ //This function intelligently creates a pointer x,
+ //which will be of correct type and then deletes it.
+
+ switch (type)
+ {
+ case capsule_type_flo:
+ {
+ REAL *real_val = reinterpret_cast(data);
+ delete real_val;
+
+ break;
+ }
+ case capsule_type_vec:
+ {
+ JudyVec *vector_val = reinterpret_cast(data);
+ delete vector_val;
+
+ break;
+ }
+ case capsule_type_str:
+ {
+ char *char_val = reinterpret_cast(data);
+ delete char_val;
+
+ break;
+ }
+ }
+
+ data = NULL; //Null the address as well. (Used for ints too.)
+}
+
+bool Capsule::GetBool( void )
+{
+ if (type != capsule_type_bool) ThrowTypeError(capsule_type_bool);
+
+ return reinterpret_cast(data);
+}
+
+void Capsule::SetBool(bool Value)
+{
+ CheckEmpty(true);
+ type = capsule_type_bool;
+ data = reinterpret_cast(Value);
+};
+
+cell Capsule::GetInt( void )
+{
+ if (type != capsule_type_int) ThrowTypeError(capsule_type_int);
+
+ return reinterpret_cast(data);
+}
+
+void Capsule::SetInt(cell Value)
+{
+ CheckEmpty(true);
+ type = capsule_type_int;
+ data = reinterpret_cast(Value);
+};
+
+REAL Capsule::GetFlo( void )
+{
+ if (type != capsule_type_flo) ThrowTypeError(capsule_type_flo);
+
+ return *reinterpret_cast(data);
+}
+
+void Capsule::SetFlo(REAL Value)
+{
+ CheckEmpty(true);
+ type = capsule_type_flo;
+ data = new REAL(Value);
+};
+
+const JudyVec* Capsule::GetVec( void )
+{
+ if (type != capsule_type_vec) ThrowTypeError(capsule_type_vec);
+
+ return reinterpret_cast(data);
+}
+
+void Capsule::SetVec(JudyVec* Value)
+{
+ CheckEmpty(true);
+ type = capsule_type_vec;
+ data = reinterpret_cast(Value);
+}
+
+const char* Capsule::GetStr( void )
+{
+ if (type != capsule_type_str) ThrowTypeError(capsule_type_str);
+
+ return reinterpret_cast(data);
+}
+
+void Capsule::SetStr(char* Value)
+{
+ CheckEmpty(true);
+ type = capsule_type_str;
+
+ char *string_val = new char[strlen(Value)+1];
+ strcpy(string_val,Value);
+
+ data = reinterpret_cast(string_val);
+}
+
+void Capsule::GetAsStr(char* value)
+{
+ switch (type)
+ {
+ case capsule_type_bool:
+ sprintf(value, "%i",(cell)GetBool());
+ break;
+ case capsule_type_int:
+ sprintf(value, "%d", GetInt() );
+ break;
+ case capsule_type_flo:
+ sprintf(value, "%f", GetFlo() );
+ break;
+ case capsule_type_vec:
+ sprintf(value, "{%f,%f,%f}", GetVec()->first, GetVec()->second, GetVec()->third);
+ break;
+ case capsule_type_str:
+ sprintf(value, "\"%s\"", GetStr() );
+ break;
+ default:
+ sprintf(value, "-NO VALUE-");
+ }
+}
+
+void Capsule::Save(FILE* capsuleDB)
+{
+ fwrite(&type,sizeof(char),1,capsuleDB);
+
+ switch(type)
+ {
+ case capsule_type_none: { break; }
+ case capsule_type_bool: { bool var = GetBool(); fwrite(&var, sizeof(bool), 1, capsuleDB); break; }
+ case capsule_type_int: { cell var = GetInt(); fwrite(&var, sizeof(cell), 1, capsuleDB); break; }
+ case capsule_type_flo: { fwrite(reinterpret_cast(GetData()), sizeof(REAL), 1, capsuleDB); break; }
+ case capsule_type_str:
+ {
+ const char* str = GetStr();
+ size_t len = strlen(str);
+ fwrite(&len,sizeof(size_t), 1, capsuleDB);
+ fwrite(&str, sizeof(char), len, capsuleDB);
+
+ break;
+ }
+ case capsule_type_vec:
+ {
+ const JudyVec* buffer = GetVec();
+ fwrite(buffer, sizeof(JudyVec), 1, capsuleDB);
+
+ break;
+ }
+ default:
+ {
+ char value[20];
+ sprintf(value,"Invalid type found!");
+
+ throw JudyEx(value, true);
+ break;
+ }
+ };
+}
+
+void Capsule::Load(FILE* capsuleDB)
+{
+ fread(&type, sizeof(char), 1, capsuleDB);
+
+ switch(type)
+ {
+ case capsule_type_none: { CheckEmpty(true); break; }
+ case capsule_type_bool:
+ {
+ bool value = false;
+ fread(&value, sizeof(bool), 1, capsuleDB);
+ SetBool(value);
+
+ break;
+ }
+ case capsule_type_int:
+ {
+ cell value = NULL;
+ fread(&value, sizeof(cell), 1, capsuleDB);
+ SetInt(value);
+
+ break;
+ }
+ case capsule_type_flo:
+ {
+ REAL value = NULL;
+ fread(&value, sizeof(REAL), 1, capsuleDB);
+ SetFlo(value);
+
+ break;
+ }
+ case capsule_type_str:
+ {
+ size_t length;
+ fread(&length, sizeof(size_t), 1, capsuleDB);
+
+ char* value = new char[length+1];
+ fgets(value, length+1, capsuleDB);
+
+ SetStr(value);
+ delete(value);
+
+ break;
+ }
+ case capsule_type_vec:
+ {
+ JudyVec* value = new JudyVec(NULL,NULL,NULL);
+ fread(value, sizeof(JudyVec), 1, capsuleDB);
+
+ SetVec(value);
+
+ break;
+ }
+ default:
+ {
+ char value[20];
+ sprintf(value,"Invalid type found: %i",(int)type);
+
+ throw JudyEx(value, true);
+ }
+ };
+}
\ No newline at end of file
diff --git a/dlls/arrayx/Capsule.h b/dlls/arrayx/Capsule.h
new file mode 100644
index 00000000..9241ab9b
--- /dev/null
+++ b/dlls/arrayx/Capsule.h
@@ -0,0 +1,64 @@
+#ifndef _JUDYCAP_INCLUDED
+#define _JUDYCAP_INCLUDED
+
+#include "JudyIncludes.h"
+
+enum
+{
+ capsule_type_none,
+ capsule_type_bool,
+ capsule_type_int,
+ capsule_type_flo,
+ capsule_type_vec,
+ capsule_type_str
+};
+
+extern const char* capsule_types[];
+
+class Capsule
+{
+private:
+ Pvoid_t data;
+ char type;
+
+protected:
+ void Clear( void );
+ void ThrowTypeError(cell get_type);
+
+public:
+ Capsule() { data = NULL; type = capsule_type_none;}
+ ~Capsule() { Clear(); }
+
+ Capsule(bool set) { SetBool(set); }
+ Capsule(cell set) { SetInt(set); }
+ Capsule(REAL set) { SetFlo(set); }
+ Capsule(JudyVec* set) { SetVec(set); }
+ Capsule(char* set) { SetStr(set); }
+
+ bool GetBool( void );
+ void SetBool(bool set);
+
+ cell GetInt( void );
+ void SetInt(cell set);
+
+ REAL GetFlo( void );
+ void SetFlo(REAL set);
+
+ const JudyVec* GetVec( void );
+ void SetVec(JudyVec* set);
+
+ const char* GetStr( void );
+ void SetStr(char* set);
+
+ void GetAsStr(char* value);
+
+ void Load(FILE* db);
+ void Save(FILE* db);
+
+ bool CheckEmpty(bool clear);
+
+ Pvoid_t GetData( void ) { return data; }
+ char GetType( void ) { return type; }
+};
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/ComboArray.h b/dlls/arrayx/ComboArray.h
new file mode 100644
index 00000000..60cb9d4e
--- /dev/null
+++ b/dlls/arrayx/ComboArray.h
@@ -0,0 +1,79 @@
+#ifndef _COMBOARRAY_INCLUDED
+#define _COMBOARRAY_INCLUDED
+
+#include "CBinTrie.h"
+#include "CArray.h"
+#include "CBaseList.h"
+
+class ComboArray: public CBaseList
+{
+private:
+ BinTrie MasterBin;
+ Array MasterArray;
+
+public:
+ ComboArray() {}
+ ~ComboArray() { Clear(); }
+
+ Word_t Clear() { return (MasterBin.Clear() + MasterArray.Clear() ); }
+ Word_t MemoryUsed() { return (MasterBin.MemoryUsed() + MasterArray.MemoryUsed() ); }
+
+ int Delete(cell Key) { return (MasterBin.Delete(Key) + MasterArray.Delete(Key) ); }
+
+ void Set(cell Index, Pvoid_t value, bool disable_check)
+ {
+ MasterBin.Set(Index, true);
+ MasterArray.Set(Index, value, disable_check);
+ }
+
+ Pvoid_t Get(cell Index, bool disable_check = false)
+ {
+ if(MasterBin.Get(Index) == NULL) { ThrowIndexError(Index, disable_check); return NULL; }
+
+ return MasterArray.Get(Index);
+ }
+
+ template
+ void Set(cell Index, Type value)
+ {
+ MasterBin.Set(Index, true);
+ MasterArray.Set(Index, value);
+ }
+
+ template
+ Type Get(cell Index, Type example, bool disable_check = false)
+ {
+ if(MasterBin.Get(Index) == NULL) { ThrowIndexError(Index, disable_check); return (Type)NULL; }
+
+ return MasterArray.Get(Index,example);
+ }
+
+ cell First(cell Start = 0) { return MasterBin.First(Start); }
+ cell Next(cell Start = 0) { return MasterBin.Next(Start); }
+ cell Prev(cell Start = -1) { return MasterBin.Prev(Start); }
+ cell Last(cell Start = -1) { return MasterBin.Last(Start); }
+
+ cell FirstEmpty(cell Start = 0) { return MasterBin.FirstEmpty(Start); }
+ cell NextEmpty(cell Start = 0) { return MasterBin.NextEmpty(Start); }
+ cell PrevEmpty(cell Start = -1) { return MasterBin.PrevEmpty(Start); }
+ cell LastEmpty(cell Start = -1) { return MasterBin.LastEmpty(Start); }
+
+ cell ByCount(cell n, cell Start = 0) { return MasterBin.ByCount(n, Start); }
+ cell Count(cell Start = 0, cell Stop = -1) { return MasterBin.Count(Start, Stop); }
+
+ bool IsFilled(cell Index) { return ( (MasterBin.Get(Index) != NULL) ? true : false); }
+ bool IsEmpty(cell Index) { return ( (MasterBin.Get(Index) == NULL) ? true : false); }
+
+protected:
+ void ThrowIndexError(cell Index, bool disable_check = false)
+ {
+ if(disable_check == true) return;
+
+ char error[50];
+ sprintf(error,"Index %i is not set.",Index);
+
+ throw JudyEx(error,true);
+ }
+};
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/ComboTable.h b/dlls/arrayx/ComboTable.h
new file mode 100644
index 00000000..286953bd
--- /dev/null
+++ b/dlls/arrayx/ComboTable.h
@@ -0,0 +1,67 @@
+#ifndef _COMBOTABLE_INCLUDED
+#define _COMBOTABLE_INCLUDED
+
+#include "CKeytable.h"
+#include "CHashtable.h"
+#include "CBaseMap.h"
+
+class ComboTable: public CBaseMap
+{
+private:
+ Keytable MasterKey;
+ Hashtable MasterHash;
+
+public:
+ ComboTable() { }
+ ~ComboTable() { Clear(); }
+
+ Word_t Clear() { return (MasterKey.Clear() + MasterHash.Clear() ); }
+ Word_t MemoryUsed() { return (MasterKey.MemoryUsed() + MasterHash.MemoryUsed() ); }
+
+ int Delete(char* Key) { return (MasterKey.Delete(Key) + MasterHash.Delete(Key) ); }
+
+ bool IsFilled(char* Index) { return ( (MasterHash.Get(Index,(PPvoid_t)(NULL), true ) != NULL) ? true : false);}
+ bool IsEmpty(char* Index) { return ( (MasterHash.Get(Index,(PPvoid_t)(NULL), true ) == NULL) ? true : false);}
+
+ void Set(char* Index, Pvoid_t value, bool disable_check)
+ {
+ MasterHash.Set(Index, value);
+ MasterKey.Set(Index, value);
+ }
+
+ Pvoid_t Get(char* Index, bool disable_check = false)
+ {
+ return MasterHash.Get(Index, disable_check);
+ }
+
+ template
+ void Set(char* Index, Type value)
+ {
+ MasterHash.Set(Index, value);
+ MasterKey.Set(Index, value);
+ }
+
+ template
+ Type Get(char* Index, Type example, bool disable_check = false)
+ {
+ return MasterHash.Get(Index, example, disable_check);
+ }
+
+ char* First( char* Start = "") { return MasterKey.First(Start);}
+ char* Next( char* Start = "") { return MasterKey.Next(Start);}
+ char* Prev( char* Start = "") { return MasterKey.Prev(Start); }
+ char* Last( char* Start = "") { return MasterKey.Last(Start);}
+
+protected:
+ void ThrowIndexError( char* index, bool disable_check = false )
+ {
+ if(disable_check == true) return;
+
+ char value[100];
+ sprintf(value,"Function attempted to read non existant index %s", index );
+
+ throw JudyEx(value, true);
+ }
+};
+
+#endif
diff --git a/dlls/arrayx/GenericNatives.h b/dlls/arrayx/GenericNatives.h
new file mode 100644
index 00000000..e3be96c8
--- /dev/null
+++ b/dlls/arrayx/GenericNatives.h
@@ -0,0 +1,844 @@
+#ifndef _GENERIC_INC_H
+#define _GENERIC_INC_H
+
+// Master table
+ComboArray MNAME;
+
+///* MASTER FUNCTIONS *///
+
+///* Start Master Edit Funcs *///
+#ifdef JUDY_MASTER_EDIT_FUNCTIONS
+
+ #ifdef JUDY_MASTER_DELETE_FUNC
+
+ // generic_delete(id)
+ static cell AMX_NATIVE_CALL JUDY_MASTER_DELETE_FUNC(AMX *amx,cell *params)
+ {
+ try { return MNAME.Delete( params[1] ); }
+ JUDY_ERROR_CATCH("Judy Error: (No error possible) - Delete function ");
+ }
+
+ #else
+
+ #error Must Have Delete func: JUDY_MASTER_DELETE_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_MASTER_CLEAR_FUNC
+
+ // generic_clear(id)
+ static cell AMX_NATIVE_CALL JUDY_MASTER_CLEAR_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[1] );
+
+ try { return Unit->Clear(); }
+ JUDY_ERROR_CATCH("Judy Error: (Search error likely) - Clear function ");
+ }
+
+ #else
+
+ #error Must Have Clear func: JUDY_MASTER_CLEAR_FUNC not defined!
+
+ #endif
+
+///* End Master Edit Funcs *///
+#endif
+
+///* Start Master IO Funcs *///
+#ifdef JUDY_MASTER_IO_FUNCTIONS
+
+ #ifdef JUDY_MASTER_SAVE_FUNC
+
+ // generic_save(id,file[])
+ static cell AMX_NATIVE_CALL JUDY_MASTER_SAVE_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+
+ return JUDY_SAVE_FUNC(Unit, JUDY_BUILD_PATH(amx,params[2]) );
+ }
+
+ #else
+
+ #error Must Have Save func: JUDY_MASTER_SAVE_FUNC not defined properly!
+
+ #endif
+
+ #ifdef JUDY_MASTER_LOAD_FUNC
+
+ // generic_load(file[],id)
+ static cell AMX_NATIVE_CALL JUDY_MASTER_LOAD_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[2]);
+
+ return JUDY_LOAD_FUNC(Unit, JUDY_BUILD_PATH(amx,params[1]) );
+ }
+
+ #else
+
+ #error Must Have Load func: JUDY_MASTER_LOAD_FUNC not defined!
+
+ #endif
+
+///* End Master IO Funcs *///
+#endif
+
+///* Start Master Amount Funcs *///
+#ifdef JUDY_MASTER_AMOUNT_FUNCTIONS
+
+ #ifdef JUDY_MASTER_COUNT_FUNC
+
+ // generic_count(start = 0, stop = -1)
+ static cell AMX_NATIVE_CALL JUDY_MASTER_COUNT_FUNC(AMX *amx,cell *params)
+ {
+ try { return MNAME.Count(params[1],params[2] ); }
+ JUDY_ERROR_CATCH("Judy Error: (Search error likely) - Count Function ");
+ }
+
+ #else
+
+ #error Must Have Count func: JUDY_MASTER_COUNT_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_MASTER_BYCOUNT_FUNC
+
+ // generic_bycount(nth, start = -1)
+ static cell AMX_NATIVE_CALL JUDY_MASTER_BYCOUNT_FUNC(AMX *amx,cell *params)
+ {
+ try { return MNAME.ByCount(params[1],params[2] ); }
+ JUDY_ERROR_CATCH("Judy Error: (Search error likely) - ByCount Function ");
+ }
+
+ #else
+
+ #error Must Have ByCount func: JUDY_MASTER_BYCOUNT_FUNC not defined!
+
+ #endif
+
+///* End Master Amount Funcs *///
+#endif
+
+///* SLAVE FUNCTIONS *///
+
+///* Start Slave Amount Funcs *///
+#ifdef JUDY_SLAVE_AMOUNT_FUNCTIONS
+
+ #ifdef JUDY_SLAVE_COUNT_FUNC
+
+ // generic_size(id, start = 0, stop = -1)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_COUNT_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+
+ try { return Unit->Count(JUDY_GET_KEY(params,2),JUDY_GET_KEY(params, 3) ); }
+ JUDY_ERROR_CATCH("Judy Error: (Search error likely) - Slave Count Function ");
+ }
+
+ #else
+
+ #error Must Have Count func: JUDY_SLAVE_COUNT_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_BYCOUNT_FUNC
+
+ // generic_get_nth(id, nth, start = -1)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_BYCOUNT_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+
+ try { return Unit->ByCount(JUDY_GET_KEY(params,2),JUDY_GET_KEY(params, 3) ); }
+ JUDY_ERROR_CATCH("Judy Error: (Search error likely) - Slave ByCount Function ");
+ }
+
+ #else
+
+ #error Must Have ByCount func: JUDY_SLAVE_BYCOUNT_FUNC not defined!
+
+ #endif
+
+///* End Slave Amount Funcs *///
+#endif
+
+///* Start Slave Edit Funcs *///
+#ifdef JUDY_SLAVE_EDIT_FUNCTIONS
+
+ #ifdef JUDY_SLAVE_MEMORY_FUNC
+
+ // generic_memory(id)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_MEMORY_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+
+ try { return Unit->MemoryUsed(); }
+ JUDY_ERROR_CATCH("Judy Error: (Search error likely) - Slave ByCount Function ");
+ }
+
+ #else
+
+ #error Must Have Memory func: JUDY_SLAVE_MEMORY_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_ISFILLED_FUNC
+
+ // generic_isfilled(id, index)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_ISFILLED_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+
+ try { return Unit->IsFilled(JUDY_GET_KEY(params,2) ); }
+ JUDY_ERROR_CATCH("Judy Error: (No error possible) - Slave IsFilled Function ");
+ }
+
+ #else
+
+ #error Must Have IsFilled func: JUDY_SLAVE_ISFILLED_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_ISEMPTY_FUNC
+
+ // generic_isempty(id, index)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_ISEMPTY_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+
+ try { return Unit->IsEmpty(JUDY_GET_KEY(params,2) ); }
+ JUDY_ERROR_CATCH("Judy Error: (No error possible) - Slave IsEmpty Function ");
+ }
+
+ #else
+
+ #error Must Have IsEmpty func: JUDY_SLAVE_ISEMPTY_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_REMOVE_FUNC
+
+ // generic_remove(id, index)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_REMOVE_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+
+ try { return Unit->Delete(JUDY_GET_KEY(params,2) ); }
+ JUDY_ERROR_CATCH("Judy Error: (No error possible) - Slave Delete Function ");
+ }
+
+ #else
+
+ #error Must Have Delete func: JUDY_SLAVE_DELETE_FUNC not defined!
+
+ #endif
+///* End Required Slave Edit Funcs *///
+
+///* Start Slave Bool Funcs *///
+#ifdef JUDY_SLAVE_EDIT_BOOL
+
+ #ifdef JUDY_SLAVE_SET_BOOL_FUNC
+ // generic_set_bool(id, index, Bool:val)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_SET_BOOL_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ STYPE* Storage;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ bool Value = (params[3] != NULL);
+
+ Storage = reinterpret_cast( Unit->Get(Indice, true ) );
+
+ if(Storage == NULL) Storage = new STYPE(Value);
+ else Storage->SetBool(Value);
+
+ JUDY_SET_INDEX_P(Unit,Storage,Indice);
+ }
+
+ #else
+
+ #error Must Have Set func: JUDY_SLAVE_SET_BOOL_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_GET_BOOL_FUNC
+
+ // Bool:generic_get_bool(id, index, disable_check = 0)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_GET_BOOL_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ STYPE* Storage;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ bool disable_check = (params[3] != NULL);
+
+ try { Storage = reinterpret_cast( Unit->Get(Indice, disable_check ) ); }
+ JUDY_ERROR_CATCH("Judy Error: (Retrieve unset value) - Slave Get Function ");
+
+ if(Storage == NULL) return 0;
+
+ return Storage->GetBool();
+ }
+
+ #else
+
+ #error Must Have Get func: JUDY_SLAVE_GET_BOOL_FUNC not defined!
+
+ #endif
+
+///* End Slave Bool Funcs *///
+#endif
+
+///* Start Slave Int Funcs *///
+#ifdef JUDY_SLAVE_EDIT_INT
+
+ #ifdef JUDY_SLAVE_SET_INT_FUNC
+
+ // generic_set_bool(id, index, val)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_SET_INT_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ STYPE* Storage;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ cell Value = params[3];
+
+ Storage = reinterpret_cast( Unit->Get(Indice, true ) );
+
+ if(Storage == NULL) Storage = new STYPE(Value);
+ else Storage->SetInt(Value);
+
+ JUDY_SET_INDEX_P(Unit,Storage,Indice);
+ }
+
+ #else
+
+ #error Must Have Set func: JUDY_SLAVE_SET_INT_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_GET_INT_FUNC
+
+ // generic_get_int(id, index, disable_check = 0)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_GET_INT_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ STYPE* Storage;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ bool disable_check = (params[3] != NULL);
+
+ try { Storage = reinterpret_cast( Unit->Get(Indice, disable_check ) ); }
+ JUDY_ERROR_CATCH("Judy Error: (Retrieve unset value) - Slave Get Function ");
+
+ if(Storage == NULL) return 0;
+
+ return Storage->GetInt();
+ }
+
+ #else
+
+ #error Must Have Get func: JUDY_SLAVE_GET_INT_FUNC not defined!
+
+ #endif
+
+///* End Slave Int Funcs *///
+#endif
+
+///* Start Slave Float Funcs *///
+#ifdef JUDY_SLAVE_EDIT_FLO
+
+ #ifdef JUDY_SLAVE_SET_FLO_FUNC
+
+ // generic_set_float(id, index, Float:val)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_SET_FLO_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ STYPE* Storage;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ REAL Value = amx_ctof(params[3]);
+
+ Storage = reinterpret_cast( Unit->Get(Indice, true ) );
+
+ if(Storage == NULL) Storage = new STYPE(Value);
+ else Storage->SetFlo(Value);
+
+ JUDY_SET_INDEX_P(Unit,Storage,Indice);
+ }
+
+ #else
+
+ #error Must Have Set func: JUDY_SLAVE_SET_FLO_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_GET_FLO_FUNC
+
+ // Float:generic_get_float(id, index, disable_check = 0)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_GET_FLO_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ STYPE* Storage;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ bool disable_check = (params[3] != NULL);
+
+ try { Storage = reinterpret_cast( Unit->Get(Indice, disable_check ) ); }
+ JUDY_ERROR_CATCH("Judy Error: (Retrieve unset value) - Slave Get Function ");
+
+ if(Storage == NULL) return 0;
+
+ return amx_ftoc(Storage->GetFlo() );
+ }
+
+ #else
+
+ #error Must Have Get func: JUDY_SLAVE_GET_FLO_FUNC not defined!
+
+ #endif
+
+///* End Slave Float Funcs *///
+#endif
+
+///* Start Slave String Funcs *///
+#ifdef JUDY_SLAVE_EDIT_STR
+
+ #ifdef JUDY_SLAVE_SET_STR_FUNC
+
+ // generic_set_string(id, index, val[])
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_SET_STR_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ STYPE* Storage;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ char* Value = MF_GetAmxString(amx,params[3],3,NULL);
+
+ Storage = reinterpret_cast( Unit->Get(Indice, true ) );
+
+ if(Storage == NULL) Storage = new STYPE(Value);
+ else Storage->SetStr(Value);
+
+ JUDY_SET_INDEX_P(Unit,Storage,Indice);
+ }
+
+ #else
+
+ #error Must Have Set func: JUDY_SLAVE_SET_STR_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_GET_STR_FUNC
+
+ // generic_get_string(id, index, val[], len, disable_check = 0)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_GET_STR_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ STYPE* Storage;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ bool disable_check = (params[5] != NULL);
+
+ try { Storage = reinterpret_cast( Unit->Get(Indice, disable_check ) ); }
+ JUDY_ERROR_CATCH("Judy Error: (Retrieve unset value) - Slave Get Function ");
+
+ if(Storage == NULL) return 0;
+
+ return MF_SetAmxString(amx,params[3], Storage->GetStr(), params[4] );
+ }
+
+ #else
+
+ #error Must Have Get func: JUDY_SLAVE_GET_STR_FUNC not defined!
+
+ #endif
+
+///* End Slave String Funcs *///
+#endif
+
+///* Start Slave Vector Funcs *///
+#ifdef JUDY_SLAVE_EDIT_VEC
+
+ #ifdef JUDY_SLAVE_SET_VEC_FUNC
+
+ // generic_set_vec(id, index, Float:val[3])
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_SET_VEC_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ STYPE* Storage;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+
+ cell *input_vec = MF_GetAmxAddr(amx, params[3]);
+ JudyVec *Value = new JudyVec(
+ amx_ctof(input_vec[0]),
+ amx_ctof(input_vec[1]),
+ amx_ctof(input_vec[2])
+ );
+
+ Storage = reinterpret_cast( Unit->Get(Indice, true ) );
+
+ if(Storage == NULL) Storage = new STYPE(Value);
+ else Storage->SetVec(Value);
+
+ JUDY_SET_INDEX_P(Unit,Storage,Indice);
+ }
+
+ #else
+
+ #error Must Have Set func: JUDY_SLAVE_SET_VEC_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_GET_FLO_FUNC
+
+ // generic_get_vec(id,index,Float:vec[3], disable_check = 0)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_GET_VEC_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ STYPE* Storage;
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ cell *vAmx = MF_GetAmxAddr(amx, params[3]);
+ bool disable_check = (params[4] != NULL);
+
+ try { Storage = reinterpret_cast( Unit->Get(Indice, disable_check ) ); }
+ JUDY_ERROR_CATCH("Judy Error: (Retrieve unset value) - Slave Get Function ");
+
+ if(Storage == NULL)
+ {
+ vAmx[0] = amx_ftoc(0);
+ vAmx[1] = amx_ftoc(0);
+ vAmx[2] = amx_ftoc(0);
+ return 0;
+ }
+
+ JudyVec* Vec = const_cast( Storage->GetVec() );
+
+ REAL One, Two, Three;
+ Vec->Get(One, Two, Three);
+
+ vAmx[0] = amx_ftoc(One);
+ vAmx[1] = amx_ftoc(Two);
+ vAmx[2] = amx_ftoc(Three);
+
+ return 1;
+ }
+
+ #else
+
+ #error Must Have Get func: JUDY_SLAVE_GET_VEC_FUNC not defined!
+
+ #endif
+
+///* End Slave VEC Funcs *///
+#endif
+
+///* End Slave Edit Funcs *///
+#endif
+
+///* Start Slave Search Funcs
+#ifdef JUDY_SLAVE_SEARCH_FUNCTIONS
+
+ #ifdef JUDY_SLAVE_FIRST_FUNC
+ // generic_first(id, index,...)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_FIRST_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ cell* success = MF_GetAmxAddr(amx, params[3 + SE_OFFSET]);
+
+ *success = 1;
+ try { return JUDY_SET_KEY(Unit->First(Indice),3); }
+ JUDY_SEARCH_ERROR_CATCH("Judy Error (Search failed) - Slave Search Function", *success);
+ }
+
+ #else
+
+ #error Must Have Search func: JUDY_SLAVE_FIRST_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_NEXT_FUNC
+ // generic_next(id, index,...)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_NEXT_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ cell* success = MF_GetAmxAddr(amx, params[3 + SE_OFFSET]);
+
+ *success = 1;
+ try { return JUDY_SET_KEY(Unit->Next(Indice),3); }
+ JUDY_SEARCH_ERROR_CATCH("Judy Error (Search failed) - Slave Search Function", *success);
+ }
+
+ #else
+
+ #error Must Have Search func: JUDY_SLAVE_NEXT_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_PREV_FUNC
+ // generic_prev(id, index,...)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_PREV_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ cell* success = MF_GetAmxAddr(amx, params[3 + SE_OFFSET]);
+
+ *success = 1;
+ try { return JUDY_SET_KEY(Unit->Prev(Indice),3); }
+ JUDY_SEARCH_ERROR_CATCH("Judy Error (Search failed) - Slave Search Function", *success);
+ }
+
+ #else
+
+ #error Must Have Search func: JUDY_SLAVE_PREV_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_LAST_FUNC
+ // generic_first(id, index,...)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_LAST_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ cell* success = MF_GetAmxAddr(amx, params[3 + SE_OFFSET]);
+
+ *success = 1;
+ try { return JUDY_SET_KEY(Unit->Last(Indice),3); }
+ JUDY_SEARCH_ERROR_CATCH("Judy Error (Search failed) - Slave Search Function", *success);
+ }
+
+ #else
+
+ #error Must Have Search func: JUDY_SLAVE_LAST_FUNC not defined!
+
+ #endif
+
+///* End Slave Search Funcs *///
+#endif
+
+
+///* Start Slave Empty Search Funcs
+#ifdef JUDY_SLAVE_SEARCH_EMPTY_FUNCTIONS
+
+ #ifdef JUDY_SLAVE_FIRSTEMPTY_FUNC
+ // generic_firstempty(id, index,...)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_FIRSTEMPTY_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ cell* success = MF_GetAmxAddr(amx, params[3 + SE_OFFSET]);
+
+ *success = 1;
+ try { return JUDY_SET_KEY(Unit->FirstEmpty(Indice),3); }
+ JUDY_SEARCH_ERROR_CATCH("Judy Error (Search failed) - Slave Search Function", *success);
+ }
+
+ #else
+
+ #error Must Have Search func: JUDY_SLAVE_FIRSTEMPTY_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_NEXTEMPTY_FUNC
+ // generic_next(id, index,...)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_NEXTEMPTY_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ cell* success = MF_GetAmxAddr(amx, params[3 + SE_OFFSET]);
+
+ *success = 1;
+ try { return JUDY_SET_KEY(Unit->NextEmpty(Indice),3); }
+ JUDY_SEARCH_ERROR_CATCH("Judy Error (Search failed) - Slave Search Function", *success);
+ }
+
+ #else
+
+ #error Must Have Search func: JUDY_SLAVE_NEXTEMPTY_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_PREVEMPTY_FUNC
+ // generic_prev(id, index,...)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_PREVEMPTY_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ cell* success = MF_GetAmxAddr(amx, params[3 + SE_OFFSET]);
+
+ *success = 1;
+ try { return JUDY_SET_KEY(Unit->PrevEmpty(Indice),3); }
+ JUDY_SEARCH_ERROR_CATCH("Judy Error (Search failed) - Slave Search Function", *success);
+ }
+
+ #else
+
+ #error Must Have Search func: JUDY_SLAVE_PREVEMPTY_FUNC not defined!
+
+ #endif
+
+ #ifdef JUDY_SLAVE_LASTEMPTY_FUNC
+ // generic_first(id, index,...)
+ static cell AMX_NATIVE_CALL JUDY_SLAVE_LASTEMPTY_FUNC(AMX *amx,cell *params)
+ {
+ DTYPE* Unit = NULL;
+
+
+ JUDY_GET_INDEX(MNAME,Unit, params[1]);
+ ITYPE Indice = JUDY_GET_KEY(params,2);
+ cell* success = MF_GetAmxAddr(amx, params[3 + SE_OFFSET]);
+
+ *success = 1;
+ try { return JUDY_SET_KEY(Unit->LastEmpty(Indice),3); }
+ JUDY_SEARCH_ERROR_CATCH("Judy Error (Search failed) - Slave Search Function",*success);
+ }
+
+ #else
+
+ #error Must Have Search func: JUDY_SLAVE_LASTEMPTY_FUNC not defined!
+
+ #endif
+
+///* End Slave Search Empty Funcs *///
+#endif
+
+AMX_NATIVE_INFO EXPORT_NAME[] =
+{
+
+#ifdef JUDY_MASTER_EDIT_FUNCTIONS
+
+ { JUDY_MASTER_CLEAR_STR , JUDY_MASTER_CLEAR_FUNC },
+ { JUDY_MASTER_DELETE_STR , JUDY_MASTER_DELETE_FUNC },
+
+#endif
+
+#ifdef JUDY_MASTER_IO_FUNCTIONS
+
+ { JUDY_MASTER_SAVE_STR , JUDY_MASTER_SAVE_FUNC },
+ { JUDY_MASTER_LOAD_STR , JUDY_MASTER_LOAD_FUNC },
+
+#endif
+
+#ifdef JUDY_MASTER_AMOUNT_FUNCTIONS
+
+ { JUDY_MASTER_COUNT_STR , JUDY_MASTER_COUNT_FUNC },
+ { JUDY_MASTER_BYCOUNT_STR , JUDY_MASTER_BYCOUNT_FUNC },
+
+#endif
+
+#ifdef JUDY_SLAVE_AMOUNT_FUNCTIONS
+
+ { JUDY_SLAVE_COUNT_STR , JUDY_SLAVE_COUNT_FUNC },
+ { JUDY_SLAVE_BYCOUNT_STR , JUDY_SLAVE_BYCOUNT_FUNC },
+
+#endif
+
+#ifdef JUDY_SLAVE_EDIT_FUNCTIONS
+
+ { JUDY_SLAVE_MEMORY_STR , JUDY_SLAVE_MEMORY_FUNC },
+ { JUDY_SLAVE_ISFILLED_STR , JUDY_SLAVE_ISFILLED_FUNC },
+ { JUDY_SLAVE_ISEMPTY_STR , JUDY_SLAVE_ISEMPTY_FUNC },
+ { JUDY_SLAVE_REMOVE_STR , JUDY_SLAVE_REMOVE_FUNC },
+
+#ifdef JUDY_SLAVE_EDIT_BOOL
+
+ { JUDY_SLAVE_GET_BOOL_STR , JUDY_SLAVE_GET_BOOL_FUNC },
+ { JUDY_SLAVE_SET_BOOL_STR , JUDY_SLAVE_SET_BOOL_FUNC },
+
+#endif
+
+#ifdef JUDY_SLAVE_EDIT_INT
+
+ { JUDY_SLAVE_GET_INT_STR , JUDY_SLAVE_GET_INT_FUNC },
+ { JUDY_SLAVE_SET_INT_STR , JUDY_SLAVE_SET_INT_FUNC },
+
+#endif
+
+#ifdef JUDY_SLAVE_EDIT_FLO
+
+ { JUDY_SLAVE_GET_FLO_STR , JUDY_SLAVE_GET_FLO_FUNC },
+ { JUDY_SLAVE_SET_FLO_STR , JUDY_SLAVE_SET_FLO_FUNC },
+
+#endif
+
+#ifdef JUDY_SLAVE_EDIT_STR
+
+ { JUDY_SLAVE_GET_STR_STR , JUDY_SLAVE_GET_STR_FUNC },
+ { JUDY_SLAVE_SET_STR_STR , JUDY_SLAVE_SET_STR_FUNC },
+
+#endif
+
+#ifdef JUDY_SLAVE_EDIT_VEC
+
+ { JUDY_SLAVE_GET_VEC_STR , JUDY_SLAVE_GET_VEC_FUNC },
+ { JUDY_SLAVE_SET_VEC_STR , JUDY_SLAVE_SET_VEC_FUNC },
+
+#endif
+
+// End all edit functions
+#endif
+
+#ifdef JUDY_SLAVE_SEARCH_FUNCTIONS
+
+ { JUDY_SLAVE_FIRST_STR , JUDY_SLAVE_FIRST_FUNC },
+ { JUDY_SLAVE_LAST_STR , JUDY_SLAVE_LAST_FUNC },
+
+ { JUDY_SLAVE_NEXT_STR , JUDY_SLAVE_NEXT_FUNC },
+ { JUDY_SLAVE_PREV_STR , JUDY_SLAVE_PREV_FUNC },
+
+#endif
+
+#ifdef JUDY_SLAVE_SEARCH_EMPTY_FUNCTIONS
+
+ { JUDY_SLAVE_FIRSTEMPTY_STR , JUDY_SLAVE_FIRSTEMPTY_FUNC },
+ { JUDY_SLAVE_LASTEMPTY_STR , JUDY_SLAVE_LASTEMPTY_FUNC },
+
+ { JUDY_SLAVE_NEXTEMPTY_STR , JUDY_SLAVE_NEXTEMPTY_FUNC },
+ { JUDY_SLAVE_PREVEMPTY_STR , JUDY_SLAVE_PREVEMPTY_FUNC },
+
+#endif
+
+ { NULL, NULL }
+};
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/Judy.h b/dlls/arrayx/Judy.h
new file mode 100644
index 00000000..7f495a72
--- /dev/null
+++ b/dlls/arrayx/Judy.h
@@ -0,0 +1,742 @@
+#ifndef _JUDY_INCLUDED
+#define _JUDY_INCLUDED
+// _________________
+//
+// Copyright (C) 2000 - 2002 Hewlett-Packard Company
+//
+// This program is free software; you can redistribute it and/or modify it
+// under the term of the GNU Lesser General Public License as published by the
+// Free Software Foundation; either version 2 of the License, or (at your
+// option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+// for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program; if not, write to the Free Software Foundation,
+// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+// _________________
+
+// @(#) $Revision$ $Source$
+//
+// HEADER FILE FOR EXPORTED FEATURES IN JUDY LIBRARY, libJudy.*
+//
+// See the manual entries for details.
+//
+// Note: This header file uses old-style comments on #-directive lines and
+// avoids "()" on macro names in comments for compatibility with older cc -Aa
+// and some tools on some platforms.
+
+
+// PLATFORM-SPECIFIC
+
+#ifdef JU_WIN /* =============================================== */
+
+typedef __int8 int8_t;
+//typedef __int16 int16_t;
+//typedef __int32 int32_t;
+typedef __int64 int64_t;
+
+typedef char uint8_t;
+//typedef unsigned __int16 uint16_t;
+//typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+
+#else /* ================ ! JU_WIN ============================= */
+
+// ISO C99: 7.8 Format conversion of integer types
+#include /* if this FAILS, try #include */
+
+// ISO C99: 7.18 Integer types uint*_t
+#include
+
+#endif /* ================ ! JU_WIN ============================= */
+
+// ISO C99 Standard: 7.20 General utilities
+#include
+
+// ISO C99 Standard: 7.10/5.2.4.2.1 Sizes of integer types
+#include
+
+#ifdef __cplusplus /* support use by C++ code */
+extern "C" {
+#endif
+
+
+// ****************************************************************************
+// DECLARE SOME BASE TYPES IN CASE THEY ARE MISSING:
+//
+// These base types include "const" where appropriate, but only where of
+// interest to the caller. For example, a caller cares that a variable passed
+// by reference will not be modified, such as, "const void * Pindex", but not
+// that the called function internally does not modify the pointer itself, such
+// as, "void * const Pindex".
+//
+// Note that its OK to pass a Pvoid_t to a Pcvoid_t; the latter is the same,
+// only constant. Callers need to do this so they can also pass & Pvoid_t to
+// PPvoid_t (non-constant).
+
+#ifndef _PCVOID_T
+#define _PCVOID_T
+typedef const void * Pcvoid_t;
+#endif
+
+#ifndef _PVOID_T
+#define _PVOID_T
+typedef void * Pvoid_t;
+typedef void ** PPvoid_t;
+#endif
+
+#ifndef _WORD_T
+#define _WORD_T
+typedef unsigned int Word_t, * PWord_t; // expect 32-bit or 64-bit words.
+#endif
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+
+// ****************************************************************************
+// SUPPORT FOR ERROR HANDLING:
+//
+// Judy error numbers:
+//
+// Note: These are an enum so theres a related typedef, but the numbers are
+// spelled out so you can map a number back to its name.
+
+typedef enum // uint8_t -- but C does not support this type of enum.
+{
+
+// Note: JU_ERRNO_NONE and JU_ERRNO_FULL are not real errors. They specify
+// conditions which are otherwise impossible return values from 32-bit
+// Judy1Count, which has 2^32 + 1 valid returns (0..2^32) plus one error
+// return. These pseudo-errors support the return values that cannot otherwise
+// be unambiguously represented in a 32-bit word, and will never occur on a
+// 64-bit system.
+
+ JU_ERRNO_NONE = 0,
+ JU_ERRNO_FULL = 1,
+ JU_ERRNO_NFMAX = JU_ERRNO_FULL,
+
+// JU_ERRNO_NOMEM comes from malloc(3C) when Judy cannot obtain needed memory.
+// The system errno value is also set to ENOMEM. This error can be recoverable
+// if the calling application frees other memory.
+//
+// TBD: Currently there is no guarantee the Judy array has no memory leaks
+// upon JU_ERRNO_NOMEM.
+
+ JU_ERRNO_NOMEM = 2,
+
+// Problems with parameters from the calling program:
+//
+// JU_ERRNO_NULLPPARRAY means PPArray was null; perhaps PArray was passed where
+// &PArray was intended. Similarly, JU_ERRNO_NULLPINDEX means PIndex was null;
+// perhaps &Index was intended. Also, JU_ERRNO_NONNULLPARRAY,
+// JU_ERRNO_NULLPVALUE, and JU_ERRNO_UNSORTED, all added later (hence with
+// higher numbers), mean: A non-null array was passed in where a null pointer
+// was required; PValue was null; and unsorted indexes were detected.
+
+ JU_ERRNO_NULLPPARRAY = 3, // see above.
+ JU_ERRNO_NONNULLPARRAY = 10, // see above.
+ JU_ERRNO_NULLPINDEX = 4, // see above.
+ JU_ERRNO_NULLPVALUE = 11, // see above.
+ JU_ERRNO_NOTJUDY1 = 5, // PArray is not to a Judy1 array.
+ JU_ERRNO_NOTJUDYL = 6, // PArray is not to a JudyL array.
+ JU_ERRNO_NOTJUDYSL = 7, // PArray is not to a JudySL array.
+ JU_ERRNO_UNSORTED = 12, // see above.
+
+// Errors below this point are not recoverable; further tries to access the
+// Judy array might result in EFAULT and a core dump:
+//
+// JU_ERRNO_OVERRUN occurs when Judy detects, upon reallocation, that a block
+// of memory in its own freelist was modified since being freed.
+
+ JU_ERRNO_OVERRUN = 8,
+
+// JU_ERRNO_CORRUPT occurs when Judy detects an impossible value in a Judy data
+// structure:
+//
+// Note: The Judy data structure contains some redundant elements that support
+// this type of checking.
+
+ JU_ERRNO_CORRUPT = 9
+
+// Warning: At least some C or C++ compilers do not tolerate a trailing comma
+// above here. At least we know of one case, in aCC; see JAGad58928.
+
+} JU_Errno_t;
+
+
+// Judy errno structure:
+//
+// WARNING: For compatibility with possible future changes, the fields of this
+// struct should not be referenced directly. Instead use the macros supplied
+// below.
+
+// This structure should be declared on the stack in a threaded process.
+
+typedef struct J_UDY_ERROR_STRUCT
+{
+ JU_Errno_t je_Errno; // one of the enums above.
+ int je_ErrID; // often an internal source line number.
+ Word_t je_reserved[4]; // for future backward compatibility.
+
+} JError_t, * PJError_t;
+
+
+// Related macros:
+//
+// Fields from error struct:
+
+#define JU_ERRNO(PJError) ((PJError)->je_Errno)
+#define JU_ERRID(PJError) ((PJError)->je_ErrID)
+
+// For checking return values from various Judy functions:
+//
+// Note: Define JERR as -1, not as the seemingly more portable (Word_t)
+// (~0UL), to avoid a compiler "overflow in implicit constant conversion"
+// warning.
+
+#define JERR (-1) /* functions returning int or Word_t */
+#define PJERR ((Pvoid_t) (~0UL)) /* mainly for use here, see below */
+#define PPJERR ((PPvoid_t) (~0UL)) /* functions that return PPvoid_t */
+
+// Convenience macro for when detailed error information (PJError_t) is not
+// desired by the caller; a purposely short name:
+
+#define PJE0 ((PJError_t) NULL)
+
+
+// ****************************************************************************
+// JUDY FUNCTIONS:
+//
+// P_JE is a shorthand for use below:
+
+#define P_JE PJError_t PJError
+
+// ****************************************************************************
+// JUDY1 FUNCTIONS:
+
+extern int j__udy1Test( Pvoid_t Pjpm, Word_t Index);
+extern int Judy1Test( Pcvoid_t PArray, Word_t Index, P_JE);
+extern int Judy1Set( PPvoid_t PPArray, Word_t Index, P_JE);
+extern int Judy1SetArray( PPvoid_t PPArray, Word_t Count,
+ const Word_t * const PIndex,
+ P_JE);
+extern int Judy1Unset( PPvoid_t PPArray, Word_t Index, P_JE);
+extern Word_t Judy1Count( Pcvoid_t PArray, Word_t Index1,
+ Word_t Index2, P_JE);
+extern int Judy1ByCount( Pcvoid_t PArray, Word_t Count,
+ Word_t * PIndex, P_JE);
+extern Word_t Judy1FreeArray( PPvoid_t PPArray, P_JE);
+extern Word_t Judy1MemUsed( Pcvoid_t PArray);
+extern Word_t Judy1MemActive( Pcvoid_t PArray);
+extern int Judy1First( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int Judy1Next( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int j__udy1Next( Pvoid_t Pjpm, Word_t * PIndex);
+extern int Judy1Last( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int Judy1Prev( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int Judy1FirstEmpty( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int Judy1NextEmpty( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int Judy1LastEmpty( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int Judy1PrevEmpty( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+
+extern PPvoid_t j__udyLGet( Pvoid_t Pjpm, Word_t Index);
+extern PPvoid_t JudyLGet( Pcvoid_t PArray, Word_t Index, P_JE);
+extern PPvoid_t JudyLIns( PPvoid_t PPArray, Word_t Index, P_JE);
+extern int JudyLInsArray( PPvoid_t PPArray, Word_t Count,
+ const Word_t * const PIndex,
+ const Word_t * const PValue,
+
+// ****************************************************************************
+// JUDYL FUNCTIONS:
+ P_JE);
+extern int JudyLDel( PPvoid_t PPArray, Word_t Index, P_JE);
+extern Word_t JudyLCount( Pcvoid_t PArray, Word_t Index1,
+ Word_t Index2, P_JE);
+extern PPvoid_t JudyLByCount( Pcvoid_t PArray, Word_t Count,
+ Word_t * PIndex, P_JE);
+extern Word_t JudyLFreeArray( PPvoid_t PPArray, P_JE);
+extern Word_t JudyLMemUsed( Pcvoid_t PArray);
+extern Word_t JudyLMemActive( Pcvoid_t PArray);
+extern PPvoid_t JudyLFirst( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern PPvoid_t JudyLNext( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern PPvoid_t j__udyLNext( Pvoid_t Pjpm, Word_t * PIndex);
+extern PPvoid_t JudyLLast( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern PPvoid_t JudyLPrev( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int JudyLFirstEmpty( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int JudyLNextEmpty( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int JudyLLastEmpty( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+extern int JudyLPrevEmpty( Pcvoid_t PArray, Word_t * PIndex, P_JE);
+
+// ****************************************************************************
+// JUDYSL FUNCTIONS:
+
+extern PPvoid_t JudySLGet( Pcvoid_t, const uint8_t * Index, P_JE);
+extern PPvoid_t JudySLIns( PPvoid_t, const uint8_t * Index, P_JE);
+extern int JudySLDel( PPvoid_t, const uint8_t * Index, P_JE);
+extern Word_t JudySLFreeArray( PPvoid_t, P_JE);
+extern PPvoid_t JudySLFirst( Pcvoid_t, uint8_t * Index, P_JE);
+extern PPvoid_t JudySLNext( Pcvoid_t, uint8_t * Index, P_JE);
+extern PPvoid_t JudySLLast( Pcvoid_t, uint8_t * Index, P_JE);
+extern PPvoid_t JudySLPrev( Pcvoid_t, uint8_t * Index, P_JE);
+
+// ****************************************************************************
+// JUDYHSL FUNCTIONS:
+
+extern PPvoid_t JudyHSGet( Pcvoid_t, void *, Word_t);
+extern PPvoid_t JudyHSIns( PPvoid_t, void *, Word_t, P_JE);
+extern int JudyHSDel( PPvoid_t, void *, Word_t, P_JE);
+extern Word_t JudyHSFreeArray( PPvoid_t, P_JE);
+
+extern const char *Judy1MallocSizes;
+extern const char *JudyLMallocSizes;
+
+// ****************************************************************************
+// JUDY memory interface to malloc() FUNCTIONS:
+
+extern Word_t JudyMalloc(Word_t); // words reqd => words allocd.
+extern Word_t JudyMallocVirtual(Word_t); // words reqd => words allocd.
+extern void JudyFree(Pvoid_t, Word_t); // free, size in words.
+extern void JudyFreeVirtual(Pvoid_t, Word_t); // free, size in words.
+
+#define JLAP_INVALID 0x1 /* flag to mark pointer "not a Judy array" */
+
+// ****************************************************************************
+// MACRO EQUIVALENTS FOR JUDY FUNCTIONS:
+//
+// The following macros, such as J1T, are shorthands for calling Judy functions
+// with parameter address-of and detailed error checking included. Since they
+// are macros, the error checking code is replicated each time the macro is
+// used, but it runs fast in the normal case of no error.
+//
+// If the caller does not like the way the default JUDYERROR macro handles
+// errors (such as an exit(1) call when out of memory), they may define their
+// own before the "#include ". A routine such as HandleJudyError
+// could do checking on specific error numbers and print a different message
+// dependent on the error. The following is one example:
+//
+// Note: the back-slashes are removed because some compilers will not accept
+// them in comments.
+//
+// void HandleJudyError(uint8_t *, int, uint8_t *, int, int);
+// #define JUDYERROR(CallerFile, CallerLine, JudyFunc, JudyErrno, JudyErrID)
+// {
+// HandleJudyError(CallerFile, CallerLine, JudyFunc, JudyErrno, JudyErrID);
+// }
+//
+// The routine HandleJudyError could do checking on specific error numbers and
+// print a different message dependent on the error.
+//
+// The macro receives five parameters that are:
+//
+// 1. CallerFile: Source filename where a Judy call returned a serious error.
+// 2. CallerLine: Line number in that source file.
+// 3. JudyFunc: Name of Judy function reporting the error.
+// 4. JudyErrno: One of the JU_ERRNO* values enumerated above.
+// 5. JudyErrID: The je_ErrID field described above.
+
+#ifndef JUDYERROR_NOTEST
+#ifndef JUDYERROR /* supply a default error macro */
+#include
+
+#define JUDYERROR(CallerFile, CallerLine, JudyFunc, JudyErrno, JudyErrID) \
+ { \
+ (void) fprintf(stderr, "File '%s', line %d: %s(), " \
+ "JU_ERRNO_* == %d, ID == %d\n", \
+ CallerFile, CallerLine, \
+ JudyFunc, JudyErrno, JudyErrID); \
+ exit(1); \
+ }
+
+#endif /* JUDYERROR */
+#endif /* JUDYERROR_NOTEST */
+
+// If the JUDYERROR macro is not desired at all, then the following eliminates
+// it. However, the return code from each Judy function (that is, the first
+// parameter of each macro) must be checked by the caller to assure that an
+// error did not occur.
+//
+// Example:
+//
+// #define JUDYERROR_NOTEST 1
+// #include
+//
+// or use this cc option at compile time:
+//
+// cc -DJUDYERROR_NOTEST ...
+//
+// Example code:
+//
+// J1S(Rc, PArray, Index);
+// if (Rc == JERR) goto ...error
+//
+// or:
+//
+// JLI(PValue, PArray, Index);
+// if (PValue == PJERR) goto ...error
+
+
+// Internal shorthand macros for writing the J1S, etc. macros:
+
+#ifdef JUDYERROR_NOTEST /* ============================================ */
+
+// "Judy Set Error":
+
+#define J_SE(FuncName,Errno) ((void) 0)
+
+// Note: In each J_*() case below, the digit is the number of key parameters
+// to the Judy*() call. Just assign the Func result to the callers Rc value
+// without a cast because none is required, and this keeps the API simpler.
+// However, a family of different J_*() macros is needed to support the
+// different numbers of key parameters (0,1,2) and the Func return type.
+//
+// In the names below, "I" = integer result; "P" = pointer result. Note, the
+// Funcs for J_*P() return PPvoid_t, but cast this to a Pvoid_t for flexible,
+// error-free assignment, and then compare to PJERR.
+
+#define J_0I(Rc,PArray,Func,FuncName) \
+ { (Rc) = Func(PArray, PJE0); }
+
+#define J_1I(Rc,PArray,Index,Func,FuncName) \
+ { (Rc) = Func(PArray, Index, PJE0); }
+
+#define J_1P(PV,PArray,Index,Func,FuncName) \
+ { (PV) = (Pvoid_t) Func(PArray, Index, PJE0); }
+
+#define J_2I(Rc,PArray,Index,Arg2,Func,FuncName) \
+ { (Rc) = Func(PArray, Index, Arg2, PJE0); }
+
+#define J_2C(Rc,PArray,Index1,Index2,Func,FuncName) \
+ { (Rc) = Func(PArray, Index1, Index2, PJE0); }
+
+#define J_2P(PV,PArray,Index,Arg2,Func,FuncName) \
+ { (PV) = (Pvoid_t) Func(PArray, Index, Arg2, PJE0); }
+
+// Variations for Judy*Set/InsArray functions:
+
+#define J_2AI(Rc,PArray,Count,PIndex,Func,FuncName) \
+ { (Rc) = Func(PArray, Count, PIndex, PJE0); }
+#define J_3AI(Rc,PArray,Count,PIndex,PValue,Func,FuncName) \
+ { (Rc) = Func(PArray, Count, PIndex, PValue, PJE0); }
+
+#else /* ================ ! JUDYERROR_NOTEST ============================= */
+
+#define J_E(FuncName,PJE) \
+ JUDYERROR(__FILE__, __LINE__, FuncName, JU_ERRNO(PJE), JU_ERRID(PJE))
+
+#define J_SE(FuncName,Errno) \
+ { \
+ JError_t J_Error; \
+ JU_ERRNO(&J_Error) = (Errno); \
+ JU_ERRID(&J_Error) = __LINE__; \
+ J_E(FuncName, &J_Error); \
+ }
+
+// Note: In each J_*() case below, the digit is the number of key parameters
+// to the Judy*() call. Just assign the Func result to the callers Rc value
+// without a cast because none is required, and this keeps the API simpler.
+// However, a family of different J_*() macros is needed to support the
+// different numbers of key parameters (0,1,2) and the Func return type.
+//
+// In the names below, "I" = integer result; "P" = pointer result. Note, the
+// Funcs for J_*P() return PPvoid_t, but cast this to a Pvoid_t for flexible,
+// error-free assignment, and then compare to PJERR.
+
+#define J_0I(Rc,PArray,Func,FuncName) \
+ { \
+ JError_t J_Error; \
+ if (((Rc) = Func(PArray, &J_Error)) == JERR) \
+ J_E(FuncName, &J_Error); \
+ }
+
+#define J_1I(Rc,PArray,Index,Func,FuncName) \
+ { \
+ JError_t J_Error; \
+ if (((Rc) = Func(PArray, Index, &J_Error)) == JERR) \
+ J_E(FuncName, &J_Error); \
+ }
+
+#define J_1P(Rc,PArray,Index,Func,FuncName) \
+ { \
+ JError_t J_Error; \
+ if (((Rc) = (Pvoid_t) Func(PArray, Index, &J_Error)) == PJERR) \
+ J_E(FuncName, &J_Error); \
+ }
+
+#define J_2I(Rc,PArray,Index,Arg2,Func,FuncName) \
+ { \
+ JError_t J_Error; \
+ if (((Rc) = Func(PArray, Index, Arg2, &J_Error)) == JERR) \
+ J_E(FuncName, &J_Error); \
+ }
+
+// Variation for Judy*Count functions, which return 0, not JERR, for error (and
+// also for other non-error cases):
+//
+// Note: JU_ERRNO_NFMAX should only apply to 32-bit Judy1, but this header
+// file lacks the necessary ifdefs to make it go away otherwise, so always
+// check against it.
+
+#define J_2C(Rc,PArray,Index1,Index2,Func,FuncName) \
+ { \
+ JError_t J_Error; \
+ if ((((Rc) = Func(PArray, Index1, Index2, &J_Error)) == 0) \
+ && (JU_ERRNO(&J_Error) > JU_ERRNO_NFMAX)) \
+ { \
+ J_E(FuncName, &J_Error); \
+ } \
+ }
+
+#define J_2P(PV,PArray,Index,Arg2,Func,FuncName) \
+ { \
+ JError_t J_Error; \
+ if (((PV) = (Pvoid_t) Func(PArray, Index, Arg2, &J_Error)) \
+ == PJERR) J_E(FuncName, &J_Error); \
+ }
+
+// Variations for Judy*Set/InsArray functions:
+
+#define J_2AI(Rc,PArray,Count,PIndex,Func,FuncName) \
+ { \
+ JError_t J_Error; \
+ if (((Rc) = Func(PArray, Count, PIndex, &J_Error)) == JERR) \
+ J_E(FuncName, &J_Error); \
+ }
+
+#define J_3AI(Rc,PArray,Count,PIndex,PValue,Func,FuncName) \
+ { \
+ JError_t J_Error; \
+ if (((Rc) = Func(PArray, Count, PIndex, PValue, &J_Error)) \
+ == JERR) J_E(FuncName, &J_Error); \
+ }
+
+#endif /* ================ ! JUDYERROR_NOTEST ============================= */
+
+// Some of the macros are special cases that use inlined shortcuts for speed
+// with root-level leaves:
+
+// This is a slower version with current processors, but in the future...
+#ifdef notdef
+#define J1T(Rc,PArray,Index) \
+{ \
+ PWord_t P_L = (PWord_t)(PArray); \
+ (Rc) = 0; \
+ if (P_L) /* cannot be a NULL pointer */ \
+ { \
+ if (P_L[0] < 31) /* is a LeafL */ \
+ { \
+ Word_t _pop1 = P_L[0] + 1; \
+ PWord_t P_LE = P_L + _pop1; \
+ Word_t _index = 0; \
+ int ii = 0; \
+ P_L++; \
+ while (_pop1 > 4) \
+ { \
+ _pop1 /=2; \
+ _index = P_L[_pop1]; \
+ if ((Index) > _index) P_L += _pop1 + 1; \
+ } \
+ while (P_L <= P_LE) \
+ { \
+ ii++; \
+ _index = P_L[0]; \
+ if (_index >= (Index)) break; \
+ P_L++; \
+ } \
+ if (_index == (Index)) (Rc) = 1; \
+ } \
+ else \
+ { \
+ (Rc) = j__udy1Test((Pvoid_t)P_L, (Index)); \
+ } \
+ } \
+}
+#endif // notdef
+
+#define J1T(Rc,PArray,Index) \
+{ \
+ PWord_t P_L = (PWord_t)(PArray); \
+ (Rc) = 0; \
+ if (P_L) /* cannot be a NULL pointer */ \
+ { \
+ if (P_L[0] < 31) /* is a LeafL */ \
+ { \
+ Word_t _pop1 = P_L[0] + 1; \
+ Word_t _EIndex = P_L[_pop1]; \
+ if (_pop1 >= 16) \
+ { \
+ if ((Index) > P_L[_pop1/2]) P_L += _pop1/2; \
+ } \
+ if ((Index) <= _EIndex) \
+ { \
+ while((Index) > *(++P_L)); \
+ if (*P_L == (Index)) (Rc) = 1; \
+ } \
+ } \
+ else \
+ { \
+ (Rc) = j__udy1Test((Pvoid_t)P_L, Index); \
+ } \
+ } \
+}
+
+#define J1S( Rc, PArray, Index) \
+ J_1I(Rc, (&(PArray)), Index, Judy1Set, "Judy1Set")
+#define J1SA(Rc, PArray, Count, PIndex) \
+ J_2AI(Rc,(&(PArray)), Count, PIndex, Judy1SetArray, "Judy1SetArray")
+#define J1U( Rc, PArray, Index) \
+ J_1I(Rc, (&(PArray)), Index, Judy1Unset, "Judy1Unset")
+#define J1F( Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), Judy1First, "Judy1First")
+#define J1N( Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), Judy1Next, "Judy1Next")
+#define J1L( Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), Judy1Last, "Judy1Last")
+#define J1P( Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), Judy1Prev, "Judy1Prev")
+#define J1FE(Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), Judy1FirstEmpty, "Judy1FirstEmpty")
+#define J1NE(Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), Judy1NextEmpty, "Judy1NextEmpty")
+#define J1LE(Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), Judy1LastEmpty, "Judy1LastEmpty")
+#define J1PE(Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), Judy1PrevEmpty, "Judy1PrevEmpty")
+#define J1C( Rc, PArray, Index1, Index2) \
+ J_2C(Rc, PArray, Index1, Index2, Judy1Count, "Judy1Count")
+#define J1BC(Rc, PArray, Count, Index) \
+ J_2I(Rc, PArray, Count, &(Index), Judy1ByCount, "Judy1ByCount")
+#define J1FA(Rc, PArray) \
+ J_0I(Rc, (&(PArray)), Judy1FreeArray, "Judy1FreeArray")
+#define J1MU(Rc, PArray) \
+ (Rc) = Judy1MemUsed(PArray)
+
+#define JLG(PV,PArray,Index) \
+{ \
+ extern const uint8_t j__L_LeafWOffset[]; \
+ PWord_t P_L = (PWord_t)(PArray); \
+ (PV) = (Pvoid_t) NULL; \
+ if (P_L) /* cannot be a NULL pointer */ \
+ { \
+ if (P_L[0] < 31) /* is a LeafL */ \
+ { \
+ Word_t _pop1 = P_L[0] + 1; \
+ Word_t _EIndex = P_L[_pop1]; \
+ Word_t _off = j__L_LeafWOffset[_pop1] - 1; \
+ if (_pop1 >= 16) \
+ { \
+ if ((Index) > P_L[_pop1/2]) P_L += _pop1/2; \
+ } \
+ if ((Index) <= _EIndex) \
+ { \
+ while((Index) > *(++P_L)); \
+ if (*P_L == (Index)) (PV) = (Pvoid_t)(P_L+_off);\
+ } \
+ } \
+ else \
+ { \
+ (PV) = (Pvoid_t)j__udyLGet((Pvoid_t)P_L, Index); \
+ } \
+ } \
+}
+
+#define JLI( PV, PArray, Index) \
+ J_1P(PV, (&(PArray)), Index, JudyLIns, "JudyLIns")
+
+#define JLIA(Rc, PArray, Count, PIndex, PValue) \
+ J_3AI(Rc,(&(PArray)), Count, PIndex, PValue, JudyLInsArray, \
+ "JudyLInsArray")
+#define JLD( Rc, PArray, Index) \
+ J_1I(Rc, (&(PArray)), Index, JudyLDel, "JudyLDel")
+
+#define JLF( PV, PArray, Index) \
+ J_1P(PV, PArray, &(Index), JudyLFirst, "JudyLFirst")
+
+#define JLN(PV,PArray,Index) \
+{ \
+ extern const uint8_t j__L_LeafWOffset[]; \
+ PWord_t P_L = (PWord_t) (PArray); \
+ \
+ (PV) = (Pvoid_t) NULL; \
+ \
+ if (P_L) /* cannot be a NULL pointer */ \
+ { \
+ if (P_L[0] < 31) /* is a LeafL */ \
+ { \
+ Word_t _pop1 = P_L[0] + 1; \
+ Word_t _off = j__L_LeafWOffset[_pop1] -1; \
+ if ((Index) < P_L[_pop1]) \
+ { \
+ while(1) \
+ { \
+ if ((Index) < *(++P_L)) \
+ { \
+ (Index) = *P_L; \
+ (PV) = (Pvoid_t) (P_L + _off); \
+ break; \
+ } \
+ } \
+ } \
+ } \
+ else \
+ { \
+ (PV) = (Pvoid_t)JudyLNext((Pvoid_t) PArray, &(Index), PJE0); \
+ } \
+ } \
+}
+
+#define JLL( PV, PArray, Index) \
+ J_1P(PV, PArray, &(Index), JudyLLast, "JudyLLast")
+#define JLP( PV, PArray, Index) \
+ J_1P(PV, PArray, &(Index), JudyLPrev, "JudyLPrev")
+#define JLFE(Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), JudyLFirstEmpty, "JudyLFirstEmpty")
+#define JLNE(Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), JudyLNextEmpty, "JudyLNextEmpty")
+#define JLLE(Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), JudyLLastEmpty, "JudyLLastEmpty")
+#define JLPE(Rc, PArray, Index) \
+ J_1I(Rc, PArray, &(Index), JudyLPrevEmpty, "JudyLPrevEmpty")
+#define JLC( Rc, PArray, Index1, Index2) \
+ J_2C(Rc, PArray, Index1, Index2, JudyLCount, "JudyLCount")
+#define JLBC(PV, PArray, Count, Index) \
+ J_2P(PV, PArray, Count, &(Index), JudyLByCount, "JudyLByCount")
+#define JLFA(Rc, PArray) \
+ J_0I(Rc, (&(PArray)), JudyLFreeArray, "JudyLFreeArray")
+#define JLMU(Rc, PArray) \
+ (Rc) = JudyLMemUsed(PArray)
+
+#define JHSI(PV, PArray, PIndex, Count) \
+ J_2P(PV, (&(PArray)), PIndex, Count, JudyHSIns, "JudyHSIns")
+#define JHSG(PV, PArray, PIndex, Count) \
+ (PV) = (Pvoid_t) JudyHSGet(PArray, PIndex, Count)
+#define JHSD(Rc, PArray, PIndex, Count) \
+ J_2I(Rc, (&(PArray)), PIndex, Count, JudyHSDel, "JudyHSDel")
+#define JHSFA(Rc, PArray) \
+ J_0I(Rc, (&(PArray)), JudyHSFreeArray, "JudyHSFreeArray")
+
+#define JSLG( PV, PArray, Index) \
+ J_1P( PV, PArray, Index, JudySLGet, "JudySLGet")
+#define JSLI( PV, PArray, Index) \
+ J_1P( PV, (&(PArray)), Index, JudySLIns, "JudySLIns")
+#define JSLD( Rc, PArray, Index) \
+ J_1I( Rc, (&(PArray)), Index, JudySLDel, "JudySLDel")
+#define JSLF( PV, PArray, Index) \
+ J_1P( PV, PArray, Index, JudySLFirst, "JudySLFirst")
+#define JSLN( PV, PArray, Index) \
+ J_1P( PV, PArray, Index, JudySLNext, "JudySLNext")
+#define JSLL( PV, PArray, Index) \
+ J_1P( PV, PArray, Index, JudySLLast, "JudySLLast")
+#define JSLP( PV, PArray, Index) \
+ J_1P( PV, PArray, Index, JudySLPrev, "JudySLPrev")
+#define JSLFA(Rc, PArray) \
+ J_0I( Rc, (&(PArray)), JudySLFreeArray, "JudySLFreeArray")
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* ! _JUDY_INCLUDED */
diff --git a/dlls/arrayx/Judy.lib b/dlls/arrayx/Judy.lib
new file mode 100644
index 00000000..77a8964d
Binary files /dev/null and b/dlls/arrayx/Judy.lib differ
diff --git a/dlls/arrayx/JudyEx.h b/dlls/arrayx/JudyEx.h
new file mode 100644
index 00000000..1c8ecba5
--- /dev/null
+++ b/dlls/arrayx/JudyEx.h
@@ -0,0 +1,50 @@
+#ifndef _JUDYEX_INCLUDED
+#define _JUDYEX_INCLUDED
+
+#include
+
+class JudyEx
+{
+private:
+ char* ex_message;
+ bool fatal;
+
+public:
+
+ JudyEx() { ex_message = NULL; fatal = true; }
+ JudyEx(char* set, bool isfatal)
+ {
+ ex_message = new char[strlen(set) + 1];
+ strcpy(ex_message, set);
+
+ fatal = isfatal;
+ }
+
+ JudyEx(const JudyEx ©)
+ {
+ ex_message = new char[strlen(copy.ex_message) + 1];
+ strcpy(ex_message, copy.ex_message);
+
+ fatal = copy.fatal;
+ }
+
+ ~JudyEx() { delete ex_message; }
+
+ void Destroy() { delete ex_message; }
+
+ void SetIsFatal(bool isfatal) { fatal = isfatal; }
+ bool IsFatal( void ) { return fatal; }
+
+ char* SetErrorMessage(char* set)
+ {
+ ex_message = new char[strlen(set) + 1];
+ strcpy(ex_message, set);
+ }
+
+ char* ErrorMessage( void )
+ {
+ return ex_message;
+ }
+};
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/JudyExtra.cpp b/dlls/arrayx/JudyExtra.cpp
new file mode 100644
index 00000000..0655c1b9
--- /dev/null
+++ b/dlls/arrayx/JudyExtra.cpp
@@ -0,0 +1,225 @@
+#include "JudyExtra.h"
+
+bool JudyClearBinTrie(BinTrie* trie)
+{
+ Word_t trie_iten = 0;
+
+ try { trie_iten = trie->First(); }
+ catch(JudyEx& e) { return false; }
+
+ while( true )
+ {
+ trie->Delete(trie_iten);
+
+ try { trie_iten = trie->Next(trie_iten); }
+ catch(JudyEx& e) { break; }
+ }
+ return true;
+};
+
+bool JudySaveBinTrie(BinTrie* trie, char* file)
+{
+ Word_t trie_iten = 0;
+
+ try { trie_iten = trie->First(); }
+ catch(JudyEx e) { return false; }
+
+ FILE *trieDB = fopen(file,"wb");
+ if (!trieDB) return false;
+
+ bool value = false;
+
+ while( true )
+ {
+ fwrite(&trie_iten, sizeof(Word_t), 1, trieDB);
+
+ value = (trie->Get(trie_iten) != NULL);
+ fwrite(&value, sizeof(bool), 1, trieDB);
+
+ try { trie_iten = trie->Next(trie_iten); }
+ catch(JudyEx& e) { break; }
+ }
+
+ fclose(trieDB);
+ return true;
+};
+
+bool JudyLoadBinTrie(BinTrie* trie, char* file)
+{
+ FILE *trieDB = fopen(file, "ab+");
+ if (!trieDB) return false;
+
+ Word_t trie_iten = 0;
+
+ bool value = false;
+
+ while(!feof(trieDB))
+ {
+ fread(&trie_iten, sizeof(Word_t), 1, trieDB);
+ if (feof(trieDB) || ferror(trieDB)) break;
+
+ fread(&value, sizeof(bool), 1, trieDB);
+
+ trie->Set(trie_iten,value);
+ }
+
+ fclose(trieDB);
+ return true;
+}
+
+bool JudyClearList(CBaseList* list)
+{
+ Word_t list_iten = 0;
+
+ try { list_iten = list->First(); }
+ catch(JudyEx& e) { return false; }
+
+ while( true )
+ {
+ try { list->Delete(list_iten); }
+ catch(JudyEx& e) { break; }
+
+ try { list_iten = list->Next(list_iten); }
+ catch(JudyEx& e) { break; }
+ }
+ return true;
+};
+
+bool JudySaveList(CBaseList* list, char* file)
+{
+ Capsule* Storage = NULL;
+ Word_t list_iten = 0;
+ bool no_error = true;
+
+ try { list_iten = list->First(); }
+ catch(JudyEx e) { return false; }
+
+ FILE* listDB = fopen(file,"wb");
+ if (!listDB) return false;
+
+ while( true )
+ {
+ try { Storage = reinterpret_cast(list->Get(list_iten) ); }
+ catch(JudyEx& e) { no_error = false; break; }
+
+ fwrite(&list_iten, sizeof(Word_t), 1, listDB);
+ try { Storage->Save(listDB); }
+ catch(JudyEx& e) { no_error = false; break; }
+
+ try { list_iten = list->Next(list_iten); }
+ catch(JudyEx& e) { break; }
+ }
+
+ fclose(listDB);
+ return no_error;
+};
+
+bool JudyLoadList(CBaseList* list, char* file)
+{
+ FILE *listDB = fopen(file, "ab+");
+ if (!listDB) return false;
+
+ Capsule* Storage = NULL;
+ Word_t list_iten = 0;
+ bool no_error = true;
+
+ while(!feof(listDB))
+ {
+ fread(&list_iten, sizeof(Word_t), 1, listDB);
+ if (feof(listDB) || ferror(listDB)) break;
+
+ Storage = new Capsule;
+ try { Storage->Load(listDB); }
+ catch(JudyEx& e) { no_error = false; break; }
+
+ list->Set(list_iten,Storage);
+ }
+
+ fclose(listDB);
+ return no_error;
+}
+
+bool JudyClearMap(CBaseMap* map)
+{
+ char* map_iten = NULL;
+
+ try { map_iten = map->First(); }
+ catch(JudyEx& e) { return false; }
+
+ while( true )
+ {
+ try { map->Delete(map_iten); }
+ catch(JudyEx& e) { return false; }
+
+ try { map_iten = map->Next(map_iten); }
+ catch(JudyEx& e) { break; }
+ }
+
+ return true;
+};
+
+
+bool JudySaveMap(CBaseMap* map, char* file)
+{
+ Capsule* Storage = NULL;
+ char* map_iten = NULL;
+ size_t key_len = 0;
+ bool no_error = true;
+
+ try { map_iten = map->First(); }
+ catch(JudyEx& e) { return false; }
+
+ FILE *mapDB = fopen(file,"wb");
+ if (!mapDB) return false;
+
+ while( true )
+ {
+ try { Storage = reinterpret_cast(map->Get(map_iten) ); }
+ catch(JudyEx& e) { return false; }
+
+ key_len = strlen(map_iten);
+
+ fwrite(&key_len, sizeof(size_t), 1, mapDB);
+ fwrite(&map_iten, sizeof(char), strlen(map_iten), mapDB);
+
+ try { Storage->Save(mapDB); }
+ catch(JudyEx& e) { no_error = false; break; }
+
+ try { map_iten = map->Next(map_iten); }
+ catch(JudyEx& e) { break; }
+ }
+
+ fclose(mapDB);
+ return no_error;
+};
+
+bool JudyLoadMap(CBaseMap* map, char* file)
+{
+ FILE *mapDB = fopen(file, "ab+");
+ if (!mapDB) return false;
+
+ Capsule* Storage = NULL;
+ char* map_iten = NULL;
+ size_t key_len = 0;
+ bool no_error = true;
+
+ while(!feof(mapDB))
+ {
+ fread(&key_len,sizeof(size_t),1,mapDB);
+
+ map_iten = new char[key_len+1];
+ fgets(map_iten, key_len+1, mapDB);
+
+ if (feof(mapDB) || ferror(mapDB)) break;
+
+ Storage = new Capsule;
+ try { Storage->Load(mapDB); }
+ catch(JudyEx& e) { no_error = false; break; }
+
+ map->Set(map_iten,Storage);
+ delete map_iten;
+ }
+
+ fclose(mapDB);
+ return no_error;
+}
\ No newline at end of file
diff --git a/dlls/arrayx/JudyExtra.h b/dlls/arrayx/JudyExtra.h
new file mode 100644
index 00000000..8400ca77
--- /dev/null
+++ b/dlls/arrayx/JudyExtra.h
@@ -0,0 +1,20 @@
+#ifndef _JUDYARRAY_SHARED_INCLUDED
+#define _JUDYARRAY_SHARED_INCLUDED
+
+#include "CBinTrie.h"
+#include "CBaseList.h"
+#include "CBaseMap.h"
+
+extern bool JudyClearBinTrie(BinTrie* trie);
+extern bool JudySaveBinTrie(BinTrie* trie, char* file);
+extern bool JudyLoadBinTrie(BinTrie* trie, char* file);
+
+extern bool JudyClearList(CBaseList* list);
+extern bool JudySaveList(CBaseList* list, char* file);
+extern bool JudyLoadList(CBaseList* list, char* file);
+
+extern bool JudyClearMap(CBaseMap* map);
+extern bool JudySaveMap(CBaseMap* array, char* file);
+extern bool JudyLoadMap(CBaseMap* array, char* file);
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/JudyIncludes.h b/dlls/arrayx/JudyIncludes.h
new file mode 100644
index 00000000..5d4b009e
--- /dev/null
+++ b/dlls/arrayx/JudyIncludes.h
@@ -0,0 +1,43 @@
+#ifndef _JUDYINC_INCLUDED
+#define _JUDYINC_INCLUDED
+
+#include "osdefs.h"
+//#include
+
+#ifndef __linux__
+#define JU_WIN
+#endif
+
+#ifdef __WIN32__
+#define JU_WIN
+#endif
+
+#define JUDYERROR_NOTEST 1
+#include "Judy.h"
+
+#ifdef __GNUC__
+#include
+#include
+#include
+#endif
+
+#ifdef __linux__
+#include
+#else
+#define WINDOWS_LEAN_AND_MEAN
+#include
+#include
+#endif
+
+#include
+#include
+
+#include "amxxmodule.h"
+
+#include "JudyVar.h"
+#include "JudyVec.h"
+#include "JudyEx.h"
+
+#include "Capsule.h"
+
+#endif
diff --git a/dlls/arrayx/JudyVar.h b/dlls/arrayx/JudyVar.h
new file mode 100644
index 00000000..a05a2113
--- /dev/null
+++ b/dlls/arrayx/JudyVar.h
@@ -0,0 +1,70 @@
+#ifndef _JUDYVAR_H
+#define _JUDYVAR_H
+
+#if defined HAVE_STDINT_H
+ //#include
+#else
+ #if defined __LCC__ || defined __DMC__ || defined LINUX
+ #if defined HAVE_INTTYPES_H
+ #include
+ #else
+ #include
+ #endif
+ #elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
+ /* The ISO C99 defines the int16_t and int_32t types. If the compiler got
+ * here, these types are probably undefined.
+ */
+ #if defined __MACH__
+ #include
+ typedef unsigned short int uint16_t;
+ typedef unsigned long int uint32_t;
+ #elif defined __FreeBSD__
+ #include
+ #else
+ typedef short int int16_t;
+ typedef unsigned short int uint16_t;
+ #if defined SN_TARGET_PS2
+ typedef int int32_t;
+ typedef unsigned int uint32_t;
+ #else
+ typedef long int int32_t;
+ typedef unsigned long int uint32_t;
+ #endif
+ #if defined __WIN32__ || defined _WIN32 || defined WIN32
+ typedef __int64 int64_t;
+ typedef unsigned __int64 uint64_t;
+ #define HAVE_I64
+ #elif defined __GNUC__
+ typedef long long int64_t;
+ typedef unsigned long long uint64_t;
+ #define HAVE_I64
+ #endif
+ #endif
+ #endif
+#endif
+
+#if defined _LP64 || defined WIN64 || defined _WIN64
+ #if !defined __64BIT__
+ #define __64BIT__
+ #endif
+#endif
+
+#if !defined PAWN_CELL_SIZE
+ #define PAWN_CELL_SIZE 32 /* by default, use 32-bit cells */
+#endif
+#if PAWN_CELL_SIZE==16
+ typedef uint16_t ucell;
+ typedef int16_t cell;
+#elif PAWN_CELL_SIZE==32
+ typedef uint32_t ucell;
+ typedef int32_t cell;
+#define REAL float
+#elif PAWN_CELL_SIZE==64
+ typedef uint64_t ucell;
+ typedef int64_t cell;
+#define REAL double
+#else
+ #error Unsupported cell size (PAWN_CELL_SIZE)
+#endif
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/JudyVec.h b/dlls/arrayx/JudyVec.h
new file mode 100644
index 00000000..07511682
--- /dev/null
+++ b/dlls/arrayx/JudyVec.h
@@ -0,0 +1,20 @@
+#ifndef _JUDYVEC_INCLUDED
+#define _JUDYVEC_INCLUDED
+
+#include "JudyIncludes.h"
+
+class JudyVec
+{
+public:
+ REAL first;
+ REAL second;
+ REAL third;
+
+ JudyVec(REAL one, REAL two, REAL three) { Set(one, two, three); }
+ ~JudyVec() {}
+
+ void Get(REAL& one, REAL& two, REAL& three) { one = first; two = second; three = third; }
+ void Set(REAL one, REAL two, REAL three) { first = one; second = two; third = three; }
+};
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/ListNativeFunctions.h b/dlls/arrayx/ListNativeFunctions.h
new file mode 100644
index 00000000..90289463
--- /dev/null
+++ b/dlls/arrayx/ListNativeFunctions.h
@@ -0,0 +1,114 @@
+#ifndef _LIST_NATIVE_FUNC_INC_H
+#define _LIST_NATIVE_FUNC_INC_H
+
+#define JUDY_GLUE_FUNC( x , y ) x ## y
+
+#define JUDY_GLUE_STR( x, y ) #x#y
+
+#define JUDY_MASTER_EDIT_FUNCTIONS
+#define JUDY_MASTER_CLEAR_FUNC JUDY_GLUE_FUNC( list , _clear )
+#define JUDY_MASTER_CLEAR_STR JUDY_GLUE_STR ( list , _clear )
+
+#define JUDY_MASTER_DELETE_FUNC JUDY_GLUE_FUNC( list , _delete )
+#define JUDY_MASTER_DELETE_STR JUDY_GLUE_STR ( list , _delete )
+
+#define JUDY_MASTER_IO_FUNCTIONS
+
+#define JUDY_MASTER_SAVE_FUNC JUDY_GLUE_FUNC( list , _save )
+#define JUDY_MASTER_SAVE_STR JUDY_GLUE_STR ( list , _save )
+#define JUDY_SAVE_FUNC(list, file) JudySaveList ( list , file )
+
+#define JUDY_MASTER_LOAD_FUNC JUDY_GLUE_FUNC( list , _load )
+#define JUDY_MASTER_LOAD_STR JUDY_GLUE_STR ( list , _load )
+#define JUDY_LOAD_FUNC(list, file) JudyLoadList ( list , file )
+
+#define JUDY_MASTER_AMOUNT_FUNCTIONS
+#define JUDY_MASTER_COUNT_FUNC JUDY_GLUE_FUNC( list , _count )
+#define JUDY_MASTER_COUNT_STR JUDY_GLUE_STR ( list , _count )
+
+#define JUDY_MASTER_BYCOUNT_FUNC JUDY_GLUE_FUNC( list , _bycount )
+#define JUDY_MASTER_BYCOUNT_STR JUDY_GLUE_STR ( list , _bycount )
+
+#define JUDY_SLAVE_AMOUNT_FUNCTIONS
+
+#define JUDY_SLAVE_COUNT_FUNC JUDY_GLUE_FUNC( list , _size )
+#define JUDY_SLAVE_COUNT_STR JUDY_GLUE_STR ( list , _size )
+
+#define JUDY_SLAVE_BYCOUNT_FUNC JUDY_GLUE_FUNC( list , _get_nth )
+#define JUDY_SLAVE_BYCOUNT_STR JUDY_GLUE_STR ( list , _get_nth )
+
+#define JUDY_SLAVE_EDIT_FUNCTIONS
+
+#define JUDY_SLAVE_MEMORY_FUNC JUDY_GLUE_FUNC( list , _memory )
+#define JUDY_SLAVE_MEMORY_STR JUDY_GLUE_STR ( list , _memory )
+
+#define JUDY_SLAVE_ISFILLED_FUNC JUDY_GLUE_FUNC( list , _isfilled )
+#define JUDY_SLAVE_ISFILLED_STR JUDY_GLUE_STR ( list , _isfilled )
+
+#define JUDY_SLAVE_ISEMPTY_FUNC JUDY_GLUE_FUNC( list , _isempty )
+#define JUDY_SLAVE_ISEMPTY_STR JUDY_GLUE_STR ( list , _isempty )
+
+#define JUDY_SLAVE_REMOVE_FUNC JUDY_GLUE_FUNC( list , _remove )
+#define JUDY_SLAVE_REMOVE_STR JUDY_GLUE_STR ( list , _remove )
+
+#define JUDY_SLAVE_EDIT_BOOL
+#define JUDY_SLAVE_GET_BOOL_FUNC JUDY_GLUE_FUNC( list , _get_bool )
+#define JUDY_SLAVE_SET_BOOL_FUNC JUDY_GLUE_FUNC( list , _set_bool )
+
+#define JUDY_SLAVE_GET_BOOL_STR JUDY_GLUE_STR ( list , _get_bool )
+#define JUDY_SLAVE_SET_BOOL_STR JUDY_GLUE_STR ( list , _set_bool )
+
+#define JUDY_SLAVE_EDIT_INT
+#define JUDY_SLAVE_GET_INT_FUNC JUDY_GLUE_FUNC( list , _get_int )
+#define JUDY_SLAVE_SET_INT_FUNC JUDY_GLUE_FUNC( list , _set_int )
+
+#define JUDY_SLAVE_GET_INT_STR JUDY_GLUE_STR ( list , _get_int )
+#define JUDY_SLAVE_SET_INT_STR JUDY_GLUE_STR ( list , _set_int )
+
+#define JUDY_SLAVE_EDIT_FLO
+#define JUDY_SLAVE_GET_FLO_FUNC JUDY_GLUE_FUNC( list , _get_float )
+#define JUDY_SLAVE_SET_FLO_FUNC JUDY_GLUE_FUNC( list , _set_float )
+
+#define JUDY_SLAVE_GET_FLO_STR JUDY_GLUE_STR ( list , _get_float )
+#define JUDY_SLAVE_SET_FLO_STR JUDY_GLUE_STR ( list , _set_float )
+
+#define JUDY_SLAVE_EDIT_STR
+#define JUDY_SLAVE_GET_STR_FUNC JUDY_GLUE_FUNC( list , _get_string )
+#define JUDY_SLAVE_SET_STR_FUNC JUDY_GLUE_FUNC( list , _set_string )
+
+#define JUDY_SLAVE_GET_STR_STR JUDY_GLUE_STR ( list , _get_string )
+#define JUDY_SLAVE_SET_STR_STR JUDY_GLUE_STR ( list , _set_string )
+
+#define JUDY_SLAVE_EDIT_VEC
+#define JUDY_SLAVE_GET_VEC_FUNC JUDY_GLUE_FUNC( list , _get_vector )
+#define JUDY_SLAVE_SET_VEC_FUNC JUDY_GLUE_FUNC( list , _set_vector )
+
+#define JUDY_SLAVE_GET_VEC_STR JUDY_GLUE_STR ( list , _get_vector )
+#define JUDY_SLAVE_SET_VEC_STR JUDY_GLUE_STR ( list , _set_vector )
+
+#define JUDY_SLAVE_SEARCH_FUNCTIONS
+#define JUDY_SLAVE_FIRST_FUNC JUDY_GLUE_FUNC( list , _first )
+#define JUDY_SLAVE_LAST_FUNC JUDY_GLUE_FUNC( list , _last )
+
+#define JUDY_SLAVE_FIRST_STR JUDY_GLUE_STR ( list , _first )
+#define JUDY_SLAVE_LAST_STR JUDY_GLUE_STR ( list , _last )
+
+#define JUDY_SLAVE_NEXT_FUNC JUDY_GLUE_FUNC( list , _next )
+#define JUDY_SLAVE_PREV_FUNC JUDY_GLUE_FUNC( list , _prev )
+
+#define JUDY_SLAVE_NEXT_STR JUDY_GLUE_STR ( list , _next )
+#define JUDY_SLAVE_PREV_STR JUDY_GLUE_STR ( list , _prev )
+
+#define JUDY_SLAVE_SEARCH_EMPTY_FUNCTIONS
+#define JUDY_SLAVE_FIRSTEMPTY_FUNC JUDY_GLUE_FUNC( list , _firstempty )
+#define JUDY_SLAVE_LASTEMPTY_FUNC JUDY_GLUE_FUNC( list , _lastempty )
+
+#define JUDY_SLAVE_FIRSTEMPTY_STR JUDY_GLUE_STR ( list , _firstempty )
+#define JUDY_SLAVE_LASTEMPTY_STR JUDY_GLUE_STR ( list , _lastempty )
+
+#define JUDY_SLAVE_NEXTEMPTY_FUNC JUDY_GLUE_FUNC( list , _nextempty )
+#define JUDY_SLAVE_PREVEMPTY_FUNC JUDY_GLUE_FUNC( list , _prevempty )
+
+#define JUDY_SLAVE_NEXTEMPTY_STR JUDY_GLUE_STR ( list , _nextempty )
+#define JUDY_SLAVE_PREVEMPTY_STR JUDY_GLUE_STR ( list , _prevempty )
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/ListNatives.cpp b/dlls/arrayx/ListNatives.cpp
new file mode 100644
index 00000000..8e50be6d
--- /dev/null
+++ b/dlls/arrayx/ListNatives.cpp
@@ -0,0 +1,43 @@
+#include "CBaseList.h"
+#include "CArray.h"
+#include "ComboArray.h"
+
+#define KEY_TYPE cell
+#define DYNAMIC_UNIT_TYPE CBaseList
+#define STORAGE_TYPE Capsule
+#define MASTER_NAME MasterList
+#define EXPORT_NAME list_exports
+
+#define SEARCH_ERROR_OFFSET 0
+
+#define GET_KEY(params, num) params[num]
+#define SET_KEY(stuff, parameter) stuff
+
+#include "ListNativeFunctions.h"
+#include "NativeIncludes.h"
+
+static cell AMX_NATIVE_CALL array_create(AMX *amx,cell *params)
+{
+ DTYPE* Unit;
+ M_ITYPE Index = params[1];
+
+ JUDY_CREATE_INDEX(MNAME,Unit,Array,Index);
+ return Index;
+}
+
+static cell AMX_NATIVE_CALL comboarray_create(AMX *amx,cell *params)
+{
+ DTYPE* Unit;
+ M_ITYPE Index = params[1];
+
+ JUDY_CREATE_INDEX(MNAME,Unit,ComboArray,Index);
+ return Index;
+}
+
+AMX_NATIVE_INFO list_creation_exports[] =
+{
+ { "array_create", array_create },
+ { "comboarray_create", comboarray_create },
+
+ { NULL, NULL }
+};
\ No newline at end of file
diff --git a/dlls/arrayx/MapNativeFunctions.h b/dlls/arrayx/MapNativeFunctions.h
new file mode 100644
index 00000000..fdd28bdd
--- /dev/null
+++ b/dlls/arrayx/MapNativeFunctions.h
@@ -0,0 +1,94 @@
+#ifndef _MAP_NATIVE_FUNC_INC_H
+#define _MAP_NATIVE_FUNC_INC_H
+
+#define JUDY_GLUE_FUNC( x , y ) x ## y
+
+#define JUDY_GLUE_STR( x, y ) #x#y
+
+#define JUDY_MASTER_EDIT_FUNCTIONS
+#define JUDY_MASTER_CLEAR_FUNC JUDY_GLUE_FUNC( map , _clear )
+#define JUDY_MASTER_CLEAR_STR JUDY_GLUE_STR ( map , _clear )
+
+#define JUDY_MASTER_DELETE_FUNC JUDY_GLUE_FUNC( map , _delete )
+#define JUDY_MASTER_DELETE_STR JUDY_GLUE_STR ( map , _delete )
+
+#define JUDY_MASTER_IO_FUNCTIONS
+
+#define JUDY_MASTER_SAVE_FUNC JUDY_GLUE_FUNC( map , _save )
+#define JUDY_MASTER_SAVE_STR JUDY_GLUE_STR ( map , _save )
+#define JUDY_SAVE_FUNC(map, file) JudySaveMap ( map , file )
+
+#define JUDY_MASTER_LOAD_FUNC JUDY_GLUE_FUNC( map , _load )
+#define JUDY_MASTER_LOAD_STR JUDY_GLUE_STR ( map , _load )
+#define JUDY_LOAD_FUNC(map, file) JudyLoadMap ( map , file )
+
+#define JUDY_MASTER_AMOUNT_FUNCTIONS
+#define JUDY_MASTER_COUNT_FUNC JUDY_GLUE_FUNC( map , _count )
+#define JUDY_MASTER_COUNT_STR JUDY_GLUE_STR ( map , _count )
+
+#define JUDY_MASTER_BYCOUNT_FUNC JUDY_GLUE_FUNC( map , _bycount )
+#define JUDY_MASTER_BYCOUNT_STR JUDY_GLUE_STR ( map , _bycount )
+
+#define JUDY_SLAVE_EDIT_FUNCTIONS
+
+#define JUDY_SLAVE_MEMORY_FUNC JUDY_GLUE_FUNC( map , _memory )
+#define JUDY_SLAVE_MEMORY_STR JUDY_GLUE_STR ( map , _memory )
+
+#define JUDY_SLAVE_ISFILLED_FUNC JUDY_GLUE_FUNC( map , _isfilled )
+#define JUDY_SLAVE_ISFILLED_STR JUDY_GLUE_STR ( map , _isfilled )
+
+#define JUDY_SLAVE_ISEMPTY_FUNC JUDY_GLUE_FUNC( map , _isempty )
+#define JUDY_SLAVE_ISEMPTY_STR JUDY_GLUE_STR ( map , _isempty )
+
+#define JUDY_SLAVE_REMOVE_FUNC JUDY_GLUE_FUNC( map , _remove )
+#define JUDY_SLAVE_REMOVE_STR JUDY_GLUE_STR ( map , _remove )
+
+#define JUDY_SLAVE_EDIT_BOOL
+#define JUDY_SLAVE_GET_BOOL_FUNC JUDY_GLUE_FUNC( map , _get_bool )
+#define JUDY_SLAVE_SET_BOOL_FUNC JUDY_GLUE_FUNC( map , _set_bool )
+
+#define JUDY_SLAVE_GET_BOOL_STR JUDY_GLUE_STR ( map , _get_bool )
+#define JUDY_SLAVE_SET_BOOL_STR JUDY_GLUE_STR ( map , _set_bool )
+
+#define JUDY_SLAVE_EDIT_INT
+#define JUDY_SLAVE_GET_INT_FUNC JUDY_GLUE_FUNC( map , _get_int )
+#define JUDY_SLAVE_SET_INT_FUNC JUDY_GLUE_FUNC( map , _set_int )
+
+#define JUDY_SLAVE_GET_INT_STR JUDY_GLUE_STR ( map , _get_int )
+#define JUDY_SLAVE_SET_INT_STR JUDY_GLUE_STR ( map , _set_int )
+
+#define JUDY_SLAVE_EDIT_FLO
+#define JUDY_SLAVE_GET_FLO_FUNC JUDY_GLUE_FUNC( map , _get_float )
+#define JUDY_SLAVE_SET_FLO_FUNC JUDY_GLUE_FUNC( map , _set_float )
+
+#define JUDY_SLAVE_GET_FLO_STR JUDY_GLUE_STR ( map , _get_float )
+#define JUDY_SLAVE_SET_FLO_STR JUDY_GLUE_STR ( map , _set_float )
+
+#define JUDY_SLAVE_EDIT_STR
+#define JUDY_SLAVE_GET_STR_FUNC JUDY_GLUE_FUNC( map , _get_string )
+#define JUDY_SLAVE_SET_STR_FUNC JUDY_GLUE_FUNC( map , _set_string )
+
+#define JUDY_SLAVE_GET_STR_STR JUDY_GLUE_STR ( map , _get_string )
+#define JUDY_SLAVE_SET_STR_STR JUDY_GLUE_STR ( map , _set_string )
+
+#define JUDY_SLAVE_EDIT_VEC
+#define JUDY_SLAVE_GET_VEC_FUNC JUDY_GLUE_FUNC( map , _get_vector )
+#define JUDY_SLAVE_SET_VEC_FUNC JUDY_GLUE_FUNC( map , _set_vector )
+
+#define JUDY_SLAVE_GET_VEC_STR JUDY_GLUE_STR ( map , _get_vector )
+#define JUDY_SLAVE_SET_VEC_STR JUDY_GLUE_STR ( map , _set_vector )
+
+#define JUDY_SLAVE_SEARCH_FUNCTIONS
+#define JUDY_SLAVE_FIRST_FUNC JUDY_GLUE_FUNC( map , _first )
+#define JUDY_SLAVE_LAST_FUNC JUDY_GLUE_FUNC( map , _last )
+
+#define JUDY_SLAVE_FIRST_STR JUDY_GLUE_STR ( map , _first )
+#define JUDY_SLAVE_LAST_STR JUDY_GLUE_STR ( map , _last )
+
+#define JUDY_SLAVE_NEXT_FUNC JUDY_GLUE_FUNC( map , _next )
+#define JUDY_SLAVE_PREV_FUNC JUDY_GLUE_FUNC( map , _prev )
+
+#define JUDY_SLAVE_NEXT_STR JUDY_GLUE_STR ( map , _next )
+#define JUDY_SLAVE_PREV_STR JUDY_GLUE_STR ( map , _prev )
+
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/MapNatives.cpp b/dlls/arrayx/MapNatives.cpp
new file mode 100644
index 00000000..38de80e6
--- /dev/null
+++ b/dlls/arrayx/MapNatives.cpp
@@ -0,0 +1,54 @@
+#include "CBaseMap.h"
+#include "CKeytable.h"
+#include "ComboTable.h"
+#include "CHashtable.h"
+
+#define KEY_TYPE char*
+#define DYNAMIC_UNIT_TYPE CBaseMap
+#define STORAGE_TYPE Capsule
+#define MASTER_NAME MasterMap
+#define EXPORT_NAME map_exports
+
+#define SEARCH_ERROR_OFFSET 2
+
+#define GET_KEY(params, num) MF_GetAmxString(amx,params[num],num,NULL)
+#define SET_KEY(str, num) MF_SetAmxString(amx,params[num],str,params[num + 1])
+
+#include "MapNativeFunctions.h"
+#include "NativeIncludes.h"
+
+static cell AMX_NATIVE_CALL keytable_create(AMX *amx,cell *params)
+{
+ DTYPE* Unit = NULL;
+ M_ITYPE Index = NULL;
+
+ JUDY_CREATE_INDEX(MNAME,Unit,Keytable,Index);
+ return Index;
+}
+
+static cell AMX_NATIVE_CALL combotable_create(AMX *amx,cell *params)
+{
+ DTYPE* Unit = NULL;
+ M_ITYPE Index = NULL;
+
+ JUDY_CREATE_INDEX(MNAME,Unit,ComboTable,Index);
+ return Index;
+}
+
+static cell AMX_NATIVE_CALL hashtable_create(AMX *amx,cell *params)
+{
+ DTYPE* Unit;
+ M_ITYPE Index = params[1];
+
+ JUDY_CREATE_INDEX(MNAME,Unit,Hashtable,Index);
+ return Index;
+}
+
+AMX_NATIVE_INFO map_creation_exports[] =
+{
+ { "keytable_create", keytable_create },
+ { "combotable_create", combotable_create },
+ { "hashtable_create", hashtable_create },
+
+ { NULL, NULL }
+};
\ No newline at end of file
diff --git a/dlls/arrayx/NativeIncludes.h b/dlls/arrayx/NativeIncludes.h
new file mode 100644
index 00000000..dc5def17
--- /dev/null
+++ b/dlls/arrayx/NativeIncludes.h
@@ -0,0 +1,130 @@
+#ifndef _NATIVE_INC_H
+#define _NATIVE_INC_H
+
+#include "ComboArray.h"
+
+#ifndef SEARCH_ERROR_OFFSET
+#define SEARCH_ERROR_OFFSET 0
+#endif
+
+#define SE_OFFSET SEARCH_ERROR_OFFSET
+
+#ifndef STORAGE_TYPE
+#error No storage type declared
+#endif
+
+#define STYPE STORAGE_TYPE
+
+#ifndef KEY_TYPE
+#error No key type declared
+#endif
+
+#define ITYPE KEY_TYPE
+
+#ifndef DYNAMIC_UNIT_TYPE
+#error No Dynamic type declared
+#endif
+
+#define DTYPE DYNAMIC_UNIT_TYPE
+
+#ifndef MASTER_NAME
+#error No master name declared
+#endif
+
+#define MNAME MASTER_NAME
+#define M_ITYPE cell
+
+#ifndef GET_KEY
+#error No method of getting keys has been declared
+#endif
+
+#ifndef EXPORT_NAME
+#define EXPORT_NAME MNAME_exports
+#endif
+
+#define SE_OFFSET SEARCH_ERROR_OFFSET
+
+#define JUDY_GET_KEY GET_KEY
+
+#ifndef SET_KEY
+#error No method of setting keys has been declared
+#endif
+
+#define JUDY_SET_KEY SET_KEY
+
+#ifndef JUDY_ERROR_CATCH
+#define JUDY_ERROR_CATCH(x_str) \
+ catch(JudyEx& e) \
+ { \
+ if(e.IsFatal() )\
+ {\
+ MF_LogError(amx,AMX_ERR_NATIVE, "%s || Judy Error: %s", x_str, e.ErrorMessage());\
+ return NULL;\
+ };\
+ return NULL;\
+ }\
+ catch(...) { MF_LogError(amx,AMX_ERR_NATIVE,"Unknown error occured, please post a bug report at www.amxmodx.org/forums"); return NULL; }
+#endif
+
+#ifndef JUDY_SEARCH_ERROR_CATCH
+#define JUDY_SEARCH_ERROR_CATCH(x_str, success) \
+ catch(JudyEx& e) \
+ { \
+ if(e.IsFatal() )\
+ {\
+ MF_LogError(amx,AMX_ERR_NATIVE, "%s || Judy Error: %s", x_str, e.ErrorMessage());\
+ return NULL;\
+ };\
+ return (success = 0);\
+ }\
+ catch(...) { MF_LogError(amx,AMX_ERR_NATIVE,"Unknown error occured, please post a bug report at www.amxmodx.org/forums"); return NULL; }
+#endif
+
+#ifndef JUDY_CREATE_INDEX
+#define JUDY_CREATE_INDEX(master, slave, slave_type, index)\
+\
+ if( index == NULL )\
+ {\
+ try { index = master.FirstEmpty(); }\
+ JUDY_ERROR_CATCH("Unable to create new unit (out of memory)");\
+\
+ slave = new slave_type;\
+ master.Set(index,slave);\
+ } \
+ else if(master.IsEmpty(index) )\
+ {\
+ slave = new slave_type;\
+ master.Set(index,slave);\
+ }\
+ else slave = master.Get(index, slave );
+
+#endif
+
+#ifndef JUDY_GET_INDEX
+#define JUDY_GET_INDEX(master,slave, where) \
+ try { slave = master.Get(where,slave); } \
+ JUDY_ERROR_CATCH("Unable to access old unit (invalid index)");
+#endif
+
+#ifndef JUDY_SET_INDEX
+#define JUDY_SET_INDEX(master,slave, where) \
+ try { master.Set(where,slave); } \
+ JUDY_ERROR_CATCH("Unknown Error occured (No error possible) - Set Function");\
+ return 1;
+#endif
+
+#ifndef JUDY_SET_INDEX_P
+#define JUDY_SET_INDEX_P(master,slave, where) \
+ try { master->Set(where,slave); } \
+ JUDY_ERROR_CATCH("Unknown Error occured (No error possible) - Set Function");\
+ return 1;
+#endif
+
+inline char* JUDY_BUILD_PATH(AMX *amx, cell param, int buffer = 0)
+{
+ char *file = MF_GetAmxString(amx, param, 0, NULL);
+ return MF_BuildPathname("%s", file);
+}
+
+#include "GenericNatives.h"
+#endif
\ No newline at end of file
diff --git a/dlls/arrayx/amxxmodule.cpp b/dlls/arrayx/amxxmodule.cpp
new file mode 100644
index 00000000..e374e441
--- /dev/null
+++ b/dlls/arrayx/amxxmodule.cpp
@@ -0,0 +1,3078 @@
+/* AMX Mod X
+*
+* by the AMX Mod X Development Team
+* originally developed by OLO
+*
+* Parts Copyright (C) 2001-2003 Will Day
+*
+* This program is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License as published by the
+* Free Software Foundation; either version 2 of the License, or (at
+* your option) any later version.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software Foundation,
+* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*
+* In addition, as a special exception, the author gives permission to
+* link the code of this program with the Half-Life Game Engine ("HL
+* Engine") and Modified Game Libraries ("MODs") developed by Valve,
+* L.L.C ("Valve"). You must obey the GNU General Public License in all
+* respects for all of the code used other than the HL Engine and MODs
+* from Valve. If you modify this file, you may extend this exception
+* to your version of the file, but you are not obligated to do so. If
+* you do not wish to do so, delete this exception statement from your
+* version.
+*
+* Description: AMX Mod X Module Interface Functions
+*/
+
+#include
+#include
+#include
+#include
+#include
+#include "amxxmodule.h"
+
+/************* METAMOD SUPPORT *************/
+#ifdef USE_METAMOD
+
+enginefuncs_t g_engfuncs;
+globalvars_t *gpGlobals;
+
+DLL_FUNCTIONS *g_pFunctionTable;
+DLL_FUNCTIONS *g_pFunctionTable_Post;
+enginefuncs_t *g_pengfuncsTable;
+enginefuncs_t *g_pengfuncsTable_Post;
+NEW_DLL_FUNCTIONS *g_pNewFunctionsTable;
+NEW_DLL_FUNCTIONS *g_pNewFunctionsTable_Post;
+
+// GetEntityAPI2 functions
+static DLL_FUNCTIONS g_EntityAPI_Table =
+{
+#ifdef FN_GameDLLInit
+ FN_GameDLLInit,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchSpawn
+ FN_DispatchSpawn,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchThink
+ FN_DispatchThink,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchUse
+ FN_DispatchUse,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchTouch
+ FN_DispatchTouch,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchBlocked
+ FN_DispatchBlocked,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchKeyValue
+ FN_DispatchKeyValue,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchSave
+ FN_DispatchSave,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchRestore
+ FN_DispatchRestore,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchObjectCollsionBox
+ FN_DispatchObjectCollsionBox,
+#else
+ NULL,
+#endif
+#ifdef FN_SaveWriteFields
+ FN_SaveWriteFields,
+#else
+ NULL,
+#endif
+#ifdef FN_SaveReadFields
+ FN_SaveReadFields,
+#else
+ NULL,
+#endif
+#ifdef FN_SaveGlobalState
+ FN_SaveGlobalState,
+#else
+ NULL,
+#endif
+#ifdef FN_RestoreGlobalState
+ FN_RestoreGlobalState,
+#else
+ NULL,
+#endif
+#ifdef FN_ResetGlobalState
+ FN_ResetGlobalState,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientConnect
+ FN_ClientConnect,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientDisconnect
+ FN_ClientDisconnect,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientKill
+ FN_ClientKill,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientPutInServer
+ FN_ClientPutInServer,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientCommand
+ FN_ClientCommand,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientUserInfoChanged
+ FN_ClientUserInfoChanged,
+#else
+ NULL,
+#endif
+#ifdef FN_ServerActivate
+ FN_ServerActivate,
+#else
+ NULL,
+#endif
+#ifdef FN_ServerDeactivate
+ FN_ServerDeactivate,
+#else
+ NULL,
+#endif
+#ifdef FN_PlayerPreThink
+ FN_PlayerPreThink,
+#else
+ NULL,
+#endif
+#ifdef FN_PlayerPostThink
+ FN_PlayerPostThink,
+#else
+ NULL,
+#endif
+#ifdef FN_StartFrame
+ FN_StartFrame,
+#else
+ NULL,
+#endif
+#ifdef FN_ParmsNewLevel
+ FN_ParmsNewLevel,
+#else
+ NULL,
+#endif
+#ifdef FN_ParmsChangeLevel
+ FN_ParmsChangeLevel,
+#else
+ NULL,
+#endif
+#ifdef FN_GetGameDescription
+ FN_GetGameDescription,
+#else
+ NULL,
+#endif
+#ifdef FN_PlayerCustomization
+ FN_PlayerCustomization,
+#else
+ NULL,
+#endif
+#ifdef FN_SpectatorConnect
+ FN_SpectatorConnect,
+#else
+ NULL,
+#endif
+#ifdef FN_SpectatorDisconnect
+ FN_SpectatorDisconnect,
+#else
+ NULL,
+#endif
+#ifdef FN_SpectatorThink
+ FN_SpectatorThink,
+#else
+ NULL,
+#endif
+#ifdef FN_Sys_Error
+ FN_Sys_Error,
+#else
+ NULL,
+#endif
+#ifdef FN_PM_Move
+ FN_PM_Move,
+#else
+ NULL,
+#endif
+#ifdef FN_PM_Init
+ FN_PM_Init,
+#else
+ NULL,
+#endif
+#ifdef FN_PM_FindTextureType
+ FN_PM_FindTextureType,
+#else
+ NULL,
+#endif
+#ifdef FN_SetupVisibility
+ FN_SetupVisibility,
+#else
+ NULL,
+#endif
+#ifdef FN_UpdateClientData
+ FN_UpdateClientData,
+#else
+ NULL,
+#endif
+#ifdef FN_AddToFullPack
+ FN_AddToFullPack,
+#else
+ NULL,
+#endif
+#ifdef FN_CreateBaseline
+ FN_CreateBaseline,
+#else
+ NULL,
+#endif
+#ifdef FN_RegisterEncoders
+ FN_RegisterEncoders,
+#else
+ NULL,
+#endif
+#ifdef FN_GetWeaponData
+ FN_GetWeaponData,
+#else
+ NULL,
+#endif
+#ifdef FN_CmdStart
+ FN_CmdStart,
+#else
+ NULL,
+#endif
+#ifdef FN_CmdEnd
+ FN_CmdEnd,
+#else
+ NULL,
+#endif
+#ifdef FN_ConnectionlessPacket
+ FN_ConnectionlessPacket,
+#else
+ NULL,
+#endif
+#ifdef FN_GetHullBounds
+ FN_GetHullBounds,
+#else
+ NULL,
+#endif
+#ifdef FN_CreateInstancedBaselines
+ FN_CreateInstancedBaselines,
+#else
+ NULL,
+#endif
+#ifdef FN_InconsistentFile
+ FN_InconsistentFile,
+#else
+ NULL,
+#endif
+#ifdef FN_AllowLagCompensation
+ FN_AllowLagCompensation
+#else
+ NULL
+#endif
+}; // g_EntityAPI2_Table
+
+// GetEntityAPI2_Post functions
+static DLL_FUNCTIONS g_EntityAPI_Post_Table =
+{
+#ifdef FN_GameDLLInit_Post
+ FN_GameDLLInit_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchSpawn_Post
+ FN_DispatchSpawn_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchThink_Post
+ FN_DispatchThink_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchUse_Post
+ FN_DispatchUse_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchTouch_Post
+ FN_DispatchTouch_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchBlocked_Post
+ FN_DispatchBlocked_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchKeyValue_Post
+ FN_DispatchKeyValue_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchSave_Post
+ FN_DispatchSave_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchRestore_Post
+ FN_DispatchRestore_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DispatchObjectCollsionBox_Post
+ FN_DispatchObjectCollsionBox_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SaveWriteFields_Post
+ FN_SaveWriteFields_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SaveReadFields_Post
+ FN_SaveReadFields_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SaveGlobalState_Post
+ FN_SaveGlobalState_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_RestoreGlobalState_Post
+ FN_RestoreGlobalState_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ResetGlobalState_Post
+ FN_ResetGlobalState_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientConnect_Post
+ FN_ClientConnect_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientDisconnect_Post
+ FN_ClientDisconnect_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientKill_Post
+ FN_ClientKill_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientPutInServer_Post
+ FN_ClientPutInServer_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientCommand_Post
+ FN_ClientCommand_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientUserInfoChanged_Post
+ FN_ClientUserInfoChanged_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ServerActivate_Post
+ FN_ServerActivate_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ServerDeactivate_Post
+ FN_ServerDeactivate_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PlayerPreThink_Post
+ FN_PlayerPreThink_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PlayerPostThink_Post
+ FN_PlayerPostThink_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_StartFrame_Post
+ FN_StartFrame_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ParmsNewLevel_Post
+ FN_ParmsNewLevel_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ParmsChangeLevel_Post
+ FN_ParmsChangeLevel_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetGameDescription_Post
+ FN_GetGameDescription_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PlayerCustomization_Post
+ FN_PlayerCustomization_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SpectatorConnect_Post
+ FN_SpectatorConnect_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SpectatorDisconnect_Post
+ FN_SpectatorDisconnect_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SpectatorThink_Post
+ FN_SpectatorThink_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_Sys_Error_Post
+ FN_Sys_Error_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PM_Move_Post
+ FN_PM_Move_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PM_Init_Post
+ FN_PM_Init_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PM_FindTextureType_Post
+ FN_PM_FindTextureType_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetupVisibility_Post
+ FN_SetupVisibility_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_UpdateClientData_Post
+ FN_UpdateClientData_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_AddToFullPack_Post
+ FN_AddToFullPack_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CreateBaseline_Post
+ FN_CreateBaseline_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_RegisterEncoders_Post
+ FN_RegisterEncoders_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetWeaponData_Post
+ FN_GetWeaponData_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CmdStart_Post
+ FN_CmdStart_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CmdEnd_Post
+ FN_CmdEnd_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ConnectionlessPacket_Post
+ FN_ConnectionlessPacket_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetHullBounds_Post
+ FN_GetHullBounds_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CreateInstancedBaselines_Post
+ FN_CreateInstancedBaselines_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_InconsistentFile_Post
+ FN_InconsistentFile_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_AllowLagCompensation
+ FN_AllowLagCompensation,
+#else
+ NULL,
+#endif
+}; // g_EntityAPI2_Table
+
+static enginefuncs_t g_EngineFuncs_Table =
+{
+#ifdef FN_PrecacheModel
+ FN_PrecacheModel,
+#else
+ NULL,
+#endif
+#ifdef FN_PrecacheSound
+ FN_PrecacheSound,
+#else
+ NULL,
+#endif
+#ifdef FN_SetModel
+ FN_SetModel,
+#else
+ NULL,
+#endif
+#ifdef FN_ModelIndex
+ FN_ModelIndex,
+#else
+ NULL,
+#endif
+#ifdef FN_ModelFrames
+ FN_ModelFrames,
+#else
+ NULL,
+#endif
+#ifdef FN_SetSize
+ FN_SetSize,
+#else
+ NULL,
+#endif
+#ifdef FN_ChangeLevel
+ FN_ChangeLevel,
+#else
+ NULL,
+#endif
+#ifdef FN_GetSpawnParms
+ FN_GetSpawnParms,
+#else
+ NULL,
+#endif
+#ifdef FN_SaveSpawnParms
+ FN_SaveSpawnParms,
+#else
+ NULL,
+#endif
+#ifdef FN_VecToYaw
+ FN_VecToYaw,
+#else
+ NULL,
+#endif
+#ifdef FN_VecToAngles
+ FN_VecToAngles,
+#else
+ NULL,
+#endif
+#ifdef FN_MoveToOrigin
+ FN_MoveToOrigin,
+#else
+ NULL,
+#endif
+#ifdef FN_ChangeYaw
+ FN_ChangeYaw,
+#else
+ NULL,
+#endif
+#ifdef FN_ChangePitch
+ FN_ChangePitch,
+#else
+ NULL,
+#endif
+#ifdef FN_FindEntityByString
+ FN_FindEntityByString,
+#else
+ NULL,
+#endif
+#ifdef FN_GetEntityIllum
+ FN_GetEntityIllum,
+#else
+ NULL,
+#endif
+#ifdef FN_FindEntityInSphere
+ FN_FindEntityInSphere,
+#else
+ NULL,
+#endif
+#ifdef FN_FindClientInPVS
+ FN_FindClientInPVS,
+#else
+ NULL,
+#endif
+#ifdef FN_EntitiesInPVS
+ FN_EntitiesInPVS,
+#else
+ NULL,
+#endif
+#ifdef FN_MakeVectors
+ FN_MakeVectors,
+#else
+ NULL,
+#endif
+#ifdef FN_AngleVectors
+ FN_AngleVectors,
+#else
+ NULL,
+#endif
+#ifdef FN_CreateEntity
+ FN_CreateEntity,
+#else
+ NULL,
+#endif
+#ifdef FN_RemoveEntity
+ FN_RemoveEntity,
+#else
+ NULL,
+#endif
+#ifdef FN_CreateNamedEntity
+ FN_CreateNamedEntity,
+#else
+ NULL,
+#endif
+#ifdef FN_MakeStatic
+ FN_MakeStatic,
+#else
+ NULL,
+#endif
+#ifdef FN_EntIsOnFloor
+ FN_EntIsOnFloor,
+#else
+ NULL,
+#endif
+#ifdef FN_DropToFloor
+ FN_DropToFloor,
+#else
+ NULL,
+#endif
+#ifdef FN_WalkMove
+ FN_WalkMove,
+#else
+ NULL,
+#endif
+#ifdef FN_SetOrigin
+ FN_SetOrigin,
+#else
+ NULL,
+#endif
+#ifdef FN_EmitSound
+ FN_EmitSound,
+#else
+ NULL,
+#endif
+#ifdef FN_EmitAmbientSound
+ FN_EmitAmbientSound,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceLine
+ FN_TraceLine,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceToss
+ FN_TraceToss,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceMonsterHull
+ FN_TraceMonsterHull,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceHull
+ FN_TraceHull,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceModel
+ FN_TraceModel,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceTexture
+ FN_TraceTexture,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceSphere
+ FN_TraceSphere,
+#else
+ NULL,
+#endif
+#ifdef FN_GetAimVector
+ FN_GetAimVector,
+#else
+ NULL,
+#endif
+#ifdef FN_ServerCommand
+ FN_ServerCommand,
+#else
+ NULL,
+#endif
+#ifdef FN_ServerExecute
+ FN_ServerExecute,
+#else
+ NULL,
+#endif
+#ifdef FN_engClientCommand
+ FN_engClientCommand,
+#else
+ NULL,
+#endif
+#ifdef FN_ParticleEffect
+ FN_ParticleEffect,
+#else
+ NULL,
+#endif
+#ifdef FN_LightStyle
+ FN_LightStyle,
+#else
+ NULL,
+#endif
+#ifdef FN_DecalIndex
+ FN_DecalIndex,
+#else
+ NULL,
+#endif
+#ifdef FN_PointContents
+ FN_PointContents,
+#else
+ NULL,
+#endif
+#ifdef FN_MessageBegin
+ FN_MessageBegin,
+#else
+ NULL,
+#endif
+#ifdef FN_MessageEnd
+ FN_MessageEnd,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteByte
+ FN_WriteByte,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteChar
+ FN_WriteChar,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteShort
+ FN_WriteShort,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteLong
+ FN_WriteLong,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteAngle
+ FN_WriteAngle,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteCoord
+ FN_WriteCoord,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteString
+ FN_WriteString,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteEntity
+ FN_WriteEntity,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarRegister
+ FN_CVarRegister,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarGetFloat
+ FN_CVarGetFloat,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarGetString
+ FN_CVarGetString,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarSetFloat
+ FN_CVarSetFloat,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarSetString
+ FN_CVarSetString,
+#else
+ NULL,
+#endif
+#ifdef FN_AlertMessage
+ FN_AlertMessage,
+#else
+ NULL,
+#endif
+#ifdef FN_EngineFprintf
+ FN_EngineFprintf,
+#else
+ NULL,
+#endif
+#ifdef FN_PvAllocEntPrivateData
+ FN_PvAllocEntPrivateData,
+#else
+ NULL,
+#endif
+#ifdef FN_PvEntPrivateData
+ FN_PvEntPrivateData,
+#else
+ NULL,
+#endif
+#ifdef FN_FreeEntPrivateData
+ FN_FreeEntPrivateData,
+#else
+ NULL,
+#endif
+#ifdef FN_SzFromIndex
+ FN_SzFromIndex,
+#else
+ NULL,
+#endif
+#ifdef FN_AllocString
+ FN_AllocString,
+#else
+ NULL,
+#endif
+#ifdef FN_GetVarsOfEnt
+ FN_GetVarsOfEnt,
+#else
+ NULL,
+#endif
+#ifdef FN_PEntityOfEntOffset
+ FN_PEntityOfEntOffset,
+#else
+ NULL,
+#endif
+#ifdef FN_EntOffsetOfPEntity
+ FN_EntOffsetOfPEntity,
+#else
+ NULL,
+#endif
+#ifdef FN_IndexOfEdict
+ FN_IndexOfEdict,
+#else
+ NULL,
+#endif
+#ifdef FN_PEntityOfEntIndex
+ FN_PEntityOfEntIndex,
+#else
+ NULL,
+#endif
+#ifdef FN_FindEntityByVars
+ FN_FindEntityByVars,
+#else
+ NULL,
+#endif
+#ifdef FN_GetModelPtr
+ FN_GetModelPtr,
+#else
+ NULL,
+#endif
+#ifdef FN_RegUserMsg
+ FN_RegUserMsg,
+#else
+ NULL,
+#endif
+#ifdef FN_AnimationAutomove
+ FN_AnimationAutomove,
+#else
+ NULL,
+#endif
+#ifdef FN_GetBonePosition
+ FN_GetBonePosition,
+#else
+ NULL,
+#endif
+#ifdef FN_FunctionFromName
+ FN_FunctionFromName,
+#else
+ NULL,
+#endif
+#ifdef FN_NameForFunction
+ FN_NameForFunction,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientPrintf
+ FN_ClientPrintf,
+#else
+ NULL,
+#endif
+#ifdef FN_ServerPrint
+ FN_ServerPrint,
+#else
+ NULL,
+#endif
+#ifdef FN_Cmd_Args
+ FN_Cmd_Args,
+#else
+ NULL,
+#endif
+#ifdef FN_Cmd_Argv
+ FN_Cmd_Argv,
+#else
+ NULL,
+#endif
+#ifdef FN_Cmd_Argc
+ FN_Cmd_Argc,
+#else
+ NULL,
+#endif
+#ifdef FN_GetAttachment
+ FN_GetAttachment,
+#else
+ NULL,
+#endif
+#ifdef FN_CRC32_Init
+ FN_CRC32_Init,
+#else
+ NULL,
+#endif
+#ifdef FN_CRC32_ProcessBuffer
+ FN_CRC32_ProcessBuffer,
+#else
+ NULL,
+#endif
+#ifdef FN_CRC32_ProcessByte
+ FN_CRC32_ProcessByte,
+#else
+ NULL,
+#endif
+#ifdef FN_CRC32_Final
+ FN_CRC32_Final,
+#else
+ NULL,
+#endif
+#ifdef FN_RandomLong
+ FN_RandomLong,
+#else
+ NULL,
+#endif
+#ifdef FN_RandomFloat
+ FN_RandomFloat,
+#else
+ NULL,
+#endif
+#ifdef FN_SetView
+ FN_SetView,
+#else
+ NULL,
+#endif
+#ifdef FN_Time
+ FN_Time,
+#else
+ NULL,
+#endif
+#ifdef FN_CrosshairAngle
+ FN_CrosshairAngle,
+#else
+ NULL,
+#endif
+#ifdef FN_LoadFileForMe
+ FN_LoadFileForMe,
+#else
+ NULL,
+#endif
+#ifdef FN_FreeFile
+ FN_FreeFile,
+#else
+ NULL,
+#endif
+#ifdef FN_EndSection
+ FN_EndSection,
+#else
+ NULL,
+#endif
+#ifdef FN_CompareFileTime
+ FN_CompareFileTime,
+#else
+ NULL,
+#endif
+#ifdef FN_GetGameDir
+ FN_GetGameDir,
+#else
+ NULL,
+#endif
+#ifdef FN_Cvar_RegisterVariable
+ FN_Cvar_RegisterVariable,
+#else
+ NULL,
+#endif
+#ifdef FN_FadeClientVolume
+ FN_FadeClientVolume,
+#else
+ NULL,
+#endif
+#ifdef FN_SetClientMaxspeed
+ FN_SetClientMaxspeed,
+#else
+ NULL,
+#endif
+#ifdef FN_CreateFakeClient
+ FN_CreateFakeClient,
+#else
+ NULL,
+#endif
+#ifdef FN_RunPlayerMove
+ FN_RunPlayerMove,
+#else
+ NULL,
+#endif
+#ifdef FN_NumberOfEntities
+ FN_NumberOfEntities,
+#else
+ NULL,
+#endif
+#ifdef FN_GetInfoKeyBuffer
+ FN_GetInfoKeyBuffer,
+#else
+ NULL,
+#endif
+#ifdef FN_InfoKeyValue
+ FN_InfoKeyValue,
+#else
+ NULL,
+#endif
+#ifdef FN_SetKeyValue
+ FN_SetKeyValue,
+#else
+ NULL,
+#endif
+#ifdef FN_SetClientKeyValue
+ FN_SetClientKeyValue,
+#else
+ NULL,
+#endif
+#ifdef FN_IsMapValid
+ FN_IsMapValid,
+#else
+ NULL,
+#endif
+#ifdef FN_StaticDecal
+ FN_StaticDecal,
+#else
+ NULL,
+#endif
+#ifdef FN_PrecacheGeneric
+ FN_PrecacheGeneric,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPlayerUserId
+ FN_GetPlayerUserId,
+#else
+ NULL,
+#endif
+#ifdef FN_BuildSoundMsg
+ FN_BuildSoundMsg,
+#else
+ NULL,
+#endif
+#ifdef FN_IsDedicatedServer
+ FN_IsDedicatedServer,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarGetPointer
+ FN_CVarGetPointer,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPlayerWONId
+ FN_GetPlayerWONId,
+#else
+ NULL,
+#endif
+#ifdef FN_Info_RemoveKey
+ FN_Info_RemoveKey,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPhysicsKeyValue
+ FN_GetPhysicsKeyValue,
+#else
+ NULL,
+#endif
+#ifdef FN_SetPhysicsKeyValue
+ FN_SetPhysicsKeyValue,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPhysicsInfoString
+ FN_GetPhysicsInfoString,
+#else
+ NULL,
+#endif
+#ifdef FN_PrecacheEvent
+ FN_PrecacheEvent,
+#else
+ NULL,
+#endif
+#ifdef FN_PlaybackEvent
+ FN_PlaybackEvent,
+#else
+ NULL,
+#endif
+#ifdef FN_SetFatPVS
+ FN_SetFatPVS,
+#else
+ NULL,
+#endif
+#ifdef FN_SetFatPAS
+ FN_SetFatPAS,
+#else
+ NULL,
+#endif
+#ifdef FN_CheckVisibility
+ FN_CheckVisibility,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaSetField
+ FN_DeltaSetField,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaUnsetField
+ FN_DeltaUnsetField,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaAddEncoder
+ FN_DeltaAddEncoder,
+#else
+ NULL,
+#endif
+#ifdef FN_GetCurrentPlayer
+ FN_GetCurrentPlayer,
+#else
+ NULL,
+#endif
+#ifdef FN_CanSkipPlayer
+ FN_CanSkipPlayer,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaFindField
+ FN_DeltaFindField,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaSetFieldByIndex
+ FN_DeltaSetFieldByIndex,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaUnsetFieldByIndex
+ FN_DeltaUnsetFieldByIndex,
+#else
+ NULL,
+#endif
+#ifdef FN_SetGroupMask
+ FN_SetGroupMask,
+#else
+ NULL,
+#endif
+#ifdef FN_engCreateInstancedBaseline
+ FN_engCreateInstancedBaseline,
+#else
+ NULL,
+#endif
+#ifdef FN_Cvar_DirectSet
+ FN_Cvar_DirectSet,
+#else
+ NULL,
+#endif
+#ifdef FN_ForceUnmodified
+ FN_ForceUnmodified,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPlayerStats
+ FN_GetPlayerStats,
+#else
+ NULL,
+#endif
+#ifdef FN_AddServerCommand
+ FN_AddServerCommand,
+#else
+ NULL,
+#endif
+#ifdef FN_Voice_GetClientListening
+ FN_Voice_GetClientListening,
+#else
+ NULL,
+#endif
+#ifdef FN_Voice_SetClientListening
+ FN_Voice_SetClientListening,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPlayerAuthId
+ FN_GetPlayerAuthId
+#else
+ NULL
+#endif
+}; // g_EngineFuncs_Table
+
+
+static enginefuncs_t g_EngineFuncs_Post_Table =
+{
+#ifdef FN_PrecacheModel_Post
+ FN_PrecacheModel_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PrecacheSound_Post
+ FN_PrecacheSound_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetModel_Post
+ FN_SetModel_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ModelIndex_Post
+ FN_ModelIndex_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ModelFrames_Post
+ FN_ModelFrames_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetSize_Post
+ FN_SetSize_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ChangeLevel_Post
+ FN_ChangeLevel_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetSpawnParms_Post
+ FN_GetSpawnParms_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SaveSpawnParms_Post
+ FN_SaveSpawnParms_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_VecToYaw_Post
+ FN_VecToYaw_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_VecToAngles_Post
+ FN_VecToAngles_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_MoveToOrigin_Post
+ FN_MoveToOrigin_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ChangeYaw_Post
+ FN_ChangeYaw_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ChangePitch_Post
+ FN_ChangePitch_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_FindEntityByString_Post
+ FN_FindEntityByString_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetEntityIllum_Post
+ FN_GetEntityIllum_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_FindEntityInSphere_Post
+ FN_FindEntityInSphere_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_FindClientInPVS_Post
+ FN_FindClientInPVS_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_EntitiesInPVS_Post
+ FN_EntitiesInPVS_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_MakeVectors_Post
+ FN_MakeVectors_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_AngleVectors_Post
+ FN_AngleVectors_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CreateEntity_Post
+ FN_CreateEntity_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_RemoveEntity_Post
+ FN_RemoveEntity_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CreateNamedEntity_Post
+ FN_CreateNamedEntity_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_MakeStatic_Post
+ FN_MakeStatic_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_EntIsOnFloor_Post
+ FN_EntIsOnFloor_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DropToFloor_Post
+ FN_DropToFloor_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_WalkMove_Post
+ FN_WalkMove_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetOrigin_Post
+ FN_SetOrigin_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_EmitSound_Post
+ FN_EmitSound_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_EmitAmbientSound_Post
+ FN_EmitAmbientSound_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceLine_Post
+ FN_TraceLine_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceToss_Post
+ FN_TraceToss_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceMonsterHull_Post
+ FN_TraceMonsterHull_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceHull_Post
+ FN_TraceHull_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceModel_Post
+ FN_TraceModel_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceTexture_Post
+ FN_TraceTexture_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_TraceSphere_Post
+ FN_TraceSphere_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetAimVector_Post
+ FN_GetAimVector_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ServerCommand_Post
+ FN_ServerCommand_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ServerExecute_Post
+ FN_ServerExecute_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_engClientCommand_Post
+ FN_engClientCommand_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ParticleEffect_Post
+ FN_ParticleEffect_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_LightStyle_Post
+ FN_LightStyle_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DecalIndex_Post
+ FN_DecalIndex_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PointContents_Post
+ FN_PointContents_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_MessageBegin_Post
+ FN_MessageBegin_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_MessageEnd_Post
+ FN_MessageEnd_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteByte_Post
+ FN_WriteByte_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteChar_Post
+ FN_WriteChar_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteShort_Post
+ FN_WriteShort_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteLong_Post
+ FN_WriteLong_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteAngle_Post
+ FN_WriteAngle_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteCoord_Post
+ FN_WriteCoord_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteString_Post
+ FN_WriteString_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_WriteEntity_Post
+ FN_WriteEntity_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarRegister_Post
+ FN_CVarRegister_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarGetFloat_Post
+ FN_CVarGetFloat_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarGetString_Post
+ FN_CVarGetString_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarSetFloat_Post
+ FN_CVarSetFloat_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarSetString_Post
+ FN_CVarSetString_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_AlertMessage_Post
+ FN_AlertMessage_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_EngineFprintf_Post
+ FN_EngineFprintf_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PvAllocEntPrivateData_Post
+ FN_PvAllocEntPrivateData_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PvEntPrivateData_Post
+ FN_PvEntPrivateData_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_FreeEntPrivateData_Post
+ FN_FreeEntPrivateData_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SzFromIndex_Post
+ FN_SzFromIndex_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_AllocString_Post
+ FN_AllocString_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetVarsOfEnt_Post
+ FN_GetVarsOfEnt_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PEntityOfEntOffset_Post
+ FN_PEntityOfEntOffset_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_EntOffsetOfPEntity_Post
+ FN_EntOffsetOfPEntity_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_IndexOfEdict_Post
+ FN_IndexOfEdict_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PEntityOfEntIndex_Post
+ FN_PEntityOfEntIndex_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_FindEntityByVars_Post
+ FN_FindEntityByVars_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetModelPtr_Post
+ FN_GetModelPtr_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_RegUserMsg_Post
+ FN_RegUserMsg_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_AnimationAutomove_Post
+ FN_AnimationAutomove_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetBonePosition_Post
+ FN_GetBonePosition_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_FunctionFromName_Post
+ FN_FunctionFromName_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_NameForFunction_Post
+ FN_NameForFunction_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ClientPrintf_Post
+ FN_ClientPrintf_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ServerPrint_Post
+ FN_ServerPrint_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_Cmd_Args_Post
+ FN_Cmd_Args_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_Cmd_Argv_Post
+ FN_Cmd_Argv_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_Cmd_Argc_Post
+ FN_Cmd_Argc_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetAttachment_Post
+ FN_GetAttachment_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CRC32_Init_Post
+ FN_CRC32_Init_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CRC32_ProcessBuffer_Post
+ FN_CRC32_ProcessBuffer_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CRC32_ProcessByte_Post
+ FN_CRC32_ProcessByte_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CRC32_Final_Post
+ FN_CRC32_Final_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_RandomLong_Post
+ FN_RandomLong_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_RandomFloat_Post
+ FN_RandomFloat_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetView_Post
+ FN_SetView_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_Time_Post
+ FN_Time_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CrosshairAngle_Post
+ FN_CrosshairAngle_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_LoadFileForMe_Post
+ FN_LoadFileForMe_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_FreeFile_Post
+ FN_FreeFile_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_EndSection_Post
+ FN_EndSection_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CompareFileTime_Post
+ FN_CompareFileTime_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetGameDir_Post
+ FN_GetGameDir_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_Cvar_RegisterVariable_Post
+ FN_Cvar_RegisterVariable_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_FadeClientVolume_Post
+ FN_FadeClientVolume_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetClientMaxspeed_Post
+ FN_SetClientMaxspeed_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CreateFakeClient_Post
+ FN_CreateFakeClient_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_RunPlayerMove_Post
+ FN_RunPlayerMove_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_NumberOfEntities_Post
+ FN_NumberOfEntities_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetInfoKeyBuffer_Post
+ FN_GetInfoKeyBuffer_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_InfoKeyValue_Post
+ FN_InfoKeyValue_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetKeyValue_Post
+ FN_SetKeyValue_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetClientKeyValue_Post
+ FN_SetClientKeyValue_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_IsMapValid_Post
+ FN_IsMapValid_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_StaticDecal_Post
+ FN_StaticDecal_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PrecacheGeneric_Post
+ FN_PrecacheGeneric_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPlayerUserId_Post
+ FN_GetPlayerUserId_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_BuildSoundMsg_Post
+ FN_BuildSoundMsg_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_IsDedicatedServer_Post
+ FN_IsDedicatedServer_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CVarGetPointer_Post
+ FN_CVarGetPointer_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPlayerWONId_Post
+ FN_GetPlayerWONId_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_Info_RemoveKey_Post
+ FN_Info_RemoveKey_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPhysicsKeyValue_Post
+ FN_GetPhysicsKeyValue_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetPhysicsKeyValue_Post
+ FN_SetPhysicsKeyValue_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPhysicsInfoString_Post
+ FN_GetPhysicsInfoString_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PrecacheEvent_Post
+ FN_PrecacheEvent_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_PlaybackEvent_Post
+ FN_PlaybackEvent_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetFatPVS_Post
+ FN_SetFatPVS_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetFatPAS_Post
+ FN_SetFatPAS_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CheckVisibility_Post
+ FN_CheckVisibility_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaSetField_Post
+ FN_DeltaSetField_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaUnsetField_Post
+ FN_DeltaUnsetField_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaAddEncoder_Post
+ FN_DeltaAddEncoder_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetCurrentPlayer_Post
+ FN_GetCurrentPlayer_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_CanSkipPlayer_Post
+ FN_CanSkipPlayer_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaFindField_Post
+ FN_DeltaFindField_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaSetFieldByIndex_Post
+ FN_DeltaSetFieldByIndex_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_DeltaUnsetFieldByIndex_Post
+ FN_DeltaUnsetFieldByIndex_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_SetGroupMask_Post
+ FN_SetGroupMask_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_engCreateInstancedBaseline_Post
+ FN_engCreateInstancedBaseline_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_Cvar_DirectSet_Post
+ FN_Cvar_DirectSet_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ForceUnmodified_Post
+ FN_ForceUnmodified_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPlayerStats_Post
+ FN_GetPlayerStats_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_AddServerCommand_Post
+ FN_AddServerCommand_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_Voice_GetClientListening_Post
+ FN_Voice_GetClientListening_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_Voice_SetClientListening_Post
+ FN_Voice_SetClientListening_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GetPlayerAuthId_Post
+ FN_GetPlayerAuthId_Post
+#else
+ NULL
+#endif
+}; // g_EngineFuncs_Post_Table
+
+
+static NEW_DLL_FUNCTIONS g_NewFuncs_Table =
+{
+#ifdef FN_OnFreeEntPrivateData
+ FN_OnFreeEntPrivateData,
+#else
+ NULL,
+#endif
+#ifdef FN_GameShutdown
+ FN_GameShutdown,
+#else
+ NULL,
+#endif
+#ifdef FN_ShouldCollide
+ ShouldCollide,
+#else
+ NULL,
+#endif
+};
+
+
+static NEW_DLL_FUNCTIONS g_NewFuncs_Post_Table =
+{
+#ifdef FN_OnFreeEntPrivateData_Post
+ FN_OnFreeEntPrivateData_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_GameShutdown_Post
+ FN_GameShutdown_Post,
+#else
+ NULL,
+#endif
+#ifdef FN_ShouldCollide_Post
+ ShouldCollide_Post,
+#else
+ NULL,
+#endif
+};
+
+// Global variables from metamod. These variable names are referenced by
+// various macros.
+meta_globals_t *gpMetaGlobals; // metamod globals
+gamedll_funcs_t *gpGamedllFuncs; // gameDLL function tables
+mutil_funcs_t *gpMetaUtilFuncs; // metamod utility functions
+
+
+plugin_info_t Plugin_info = {
+ META_INTERFACE_VERSION,
+ MODULE_NAME,
+ MODULE_VERSION,
+ MODULE_DATE,
+ MODULE_AUTHOR,
+ MODULE_URL,
+ MODULE_LOGTAG,
+ PT_ANYTIME,
+ PT_ANYTIME
+};
+
+/*
+C_DLLEXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion)
+{
+ LOG_DEVELOPER(PLID, "called: GetEntityAPI; version=%d", interfaceVersion);
+ if(!pFunctionTable) {
+ LOG_ERROR(PLID, "GetEntityAPI called with null pFunctionTable");
+ return(FALSE);
+ }
+ else if(interfaceVersion != INTERFACE_VERSION) {
+ LOG_ERROR(PLID, "GetEntityAPI version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION);
+ return(FALSE);
+ }
+ memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof( DLL_FUNCTIONS ) );
+
+ return (TRUE);
+}
+
+C_DLLEXPORT int GetEntityAPI_Post(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion)
+{
+ LOG_DEVELOPER(PLID, "called: GetEntityAPI_Post; version=%d", interfaceVersion);
+ if(!pFunctionTable) {
+ LOG_ERROR(PLID, "GetEntityAPI_Post called with null pFunctionTable");
+ return(FALSE);
+ }
+ else if(interfaceVersion != INTERFACE_VERSION) {
+ LOG_ERROR(PLID, "GetEntityAPI_Post version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION);
+ return(FALSE);
+ }
+ memcpy(pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) );
+
+ return(TRUE);
+}
+*/
+
+C_DLLEXPORT int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
+{
+ LOG_DEVELOPER(PLID, "called: GetEntityAPI2; version=%d", *interfaceVersion);
+ if(!pFunctionTable) {
+ LOG_ERROR(PLID, "GetEntityAPI2 called with null pFunctionTable");
+ return(FALSE);
+ }
+ else if(*interfaceVersion != INTERFACE_VERSION) {
+ LOG_ERROR(PLID,
+ "GetEntityAPI2 version mismatch; requested=%d ours=%d",
+ *interfaceVersion, INTERFACE_VERSION);
+ //! Tell engine what version we had, so it can figure out who is
+ //! out of date.
+ *interfaceVersion = INTERFACE_VERSION;
+ return(FALSE);
+ }
+ memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof(DLL_FUNCTIONS));
+ g_pFunctionTable=pFunctionTable;
+ return(TRUE);
+}
+
+C_DLLEXPORT int GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
+{
+ LOG_DEVELOPER(PLID, "called: GetEntityAPI2_Post; version=%d", *interfaceVersion);
+ if(!pFunctionTable) {
+ LOG_ERROR(PLID, "GetEntityAPI2_Post called with null pFunctionTable");
+ return(FALSE);
+ }
+ else if(*interfaceVersion != INTERFACE_VERSION) {
+ LOG_ERROR(PLID, "GetEntityAPI2_Post version mismatch; requested=%d ours=%d", *interfaceVersion, INTERFACE_VERSION);
+ //! Tell engine what version we had, so it can figure out who is out of date.
+ *interfaceVersion = INTERFACE_VERSION;
+ return(FALSE);
+ }
+ memcpy( pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) );
+ g_pFunctionTable_Post=pFunctionTable;
+ return(TRUE);
+}
+
+C_DLLEXPORT int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion)
+{
+ LOG_DEVELOPER(PLID, "called: GetEngineFunctions; version=%d",
+ *interfaceVersion);
+ if(!pengfuncsFromEngine) {
+ LOG_ERROR(PLID,
+ "GetEngineFunctions called with null pengfuncsFromEngine");
+ return(FALSE);
+ }
+ else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) {
+ LOG_ERROR(PLID,
+ "GetEngineFunctions version mismatch; requested=%d ours=%d",
+ *interfaceVersion, ENGINE_INTERFACE_VERSION);
+ // Tell metamod what version we had, so it can figure out who is
+ // out of date.
+ *interfaceVersion = ENGINE_INTERFACE_VERSION;
+ return(FALSE);
+ }
+ memcpy(pengfuncsFromEngine, &g_EngineFuncs_Table, sizeof(enginefuncs_t));
+ g_pengfuncsTable=pengfuncsFromEngine;
+ return TRUE;
+}
+
+C_DLLEXPORT int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion)
+{
+ LOG_DEVELOPER(PLID, "called: GetEngineFunctions_Post; version=%d", *interfaceVersion);
+ if(!pengfuncsFromEngine) {
+ LOG_ERROR(PLID, "GetEngineFunctions_Post called with null pengfuncsFromEngine");
+ return(FALSE);
+ }
+ else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) {
+ LOG_ERROR(PLID, "GetEngineFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, ENGINE_INTERFACE_VERSION);
+ // Tell metamod what version we had, so it can figure out who is out of date.
+ *interfaceVersion = ENGINE_INTERFACE_VERSION;
+ return(FALSE);
+ }
+ memcpy(pengfuncsFromEngine, &g_EngineFuncs_Post_Table, sizeof(enginefuncs_t));
+ g_pengfuncsTable_Post=pengfuncsFromEngine;
+ return TRUE;
+
+}
+
+C_DLLEXPORT int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pNewFunctionTable,
+ int *interfaceVersion)
+{
+ LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions; version=%d",
+ *interfaceVersion);
+ if(!pNewFunctionTable) {
+ LOG_ERROR(PLID,
+ "GetNewDLLFunctions called with null pNewFunctionTable");
+ return(FALSE);
+ }
+ else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) {
+ LOG_ERROR(PLID,
+ "GetNewDLLFunctions version mismatch; requested=%d ours=%d",
+ *interfaceVersion, NEW_DLL_FUNCTIONS_VERSION);
+ //! Tell engine what version we had, so it can figure out who is
+ //! out of date.
+ *interfaceVersion = NEW_DLL_FUNCTIONS_VERSION;
+ return(FALSE);
+ }
+ memcpy(pNewFunctionTable, &g_NewFuncs_Table, sizeof(NEW_DLL_FUNCTIONS));
+ g_pNewFunctionsTable=pNewFunctionTable;
+ return TRUE;
+}
+
+C_DLLEXPORT int GetNewDLLFunctions_Post( NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion )
+{
+ LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions_Post; version=%d", *interfaceVersion);
+ if(!pNewFunctionTable) {
+ LOG_ERROR(PLID, "GetNewDLLFunctions_Post called with null pNewFunctionTable");
+ return(FALSE);
+ }
+ else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) {
+ LOG_ERROR(PLID, "GetNewDLLFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, NEW_DLL_FUNCTIONS_VERSION);
+ //! Tell engine what version we had, so it can figure out who is out of date.
+ *interfaceVersion = NEW_DLL_FUNCTIONS_VERSION;
+ return(FALSE);
+ }
+ memcpy(pNewFunctionTable, &g_NewFuncs_Post_Table, sizeof(NEW_DLL_FUNCTIONS));
+ g_pNewFunctionsTable_Post=pNewFunctionTable;
+ return TRUE;
+}
+
+
+static META_FUNCTIONS g_MetaFunctions_Table =
+{
+ NULL,
+ NULL,
+ GetEntityAPI2,
+ GetEntityAPI2_Post,
+ GetNewDLLFunctions,
+ GetNewDLLFunctions_Post,
+ GetEngineFunctions,
+ GetEngineFunctions_Post
+};
+
+C_DLLEXPORT int Meta_Query(char *ifvers, plugin_info_t **pPlugInfo, mutil_funcs_t *pMetaUtilFuncs)
+{
+ if ((int) CVAR_GET_FLOAT("developer") != 0)
+ UTIL_LogPrintf("[%s] dev: called: Meta_Query; version=%s, ours=%s\n",
+ Plugin_info.logtag, ifvers, Plugin_info.ifvers);
+
+ // Check for valid pMetaUtilFuncs before we continue.
+ if(!pMetaUtilFuncs) {
+ UTIL_LogPrintf("[%s] ERROR: Meta_Query called with null pMetaUtilFuncs\n", Plugin_info.logtag);
+ return(FALSE);
+ }
+
+ gpMetaUtilFuncs = pMetaUtilFuncs;
+
+ *pPlugInfo = &Plugin_info;
+
+ // Check for interface version compatibility.
+ if(!FStrEq(ifvers, Plugin_info.ifvers)) {
+ int mmajor=0, mminor=0, pmajor=0, pminor=0;
+ LOG_MESSAGE(PLID, "WARNING: meta-interface version mismatch; requested=%s ours=%s",
+ Plugin_info.logtag, ifvers);
+ // If plugin has later interface version, it's incompatible (update
+ // metamod).
+ sscanf(ifvers, "%d:%d", &mmajor, &mminor);
+ sscanf(META_INTERFACE_VERSION, "%d:%d", &pmajor, &pminor);
+ if(pmajor > mmajor || (pmajor==mmajor && pminor > mminor)) {
+ LOG_ERROR(PLID, "metamod version is too old for this module; update metamod");
+ return(FALSE);
+ }
+ // If plugin has older major interface version, it's incompatible
+ // (update plugin).
+ else if(pmajor < mmajor) {
+ LOG_ERROR(PLID, "metamod version is incompatible with this module; please find a newer version of this module");
+ return(FALSE);
+ }
+ // Minor interface is older, but this is guaranteed to be backwards
+ // compatible, so we warn, but we still accept it.
+ else if(pmajor==mmajor && pminor < mminor)
+ LOG_MESSAGE(PLID, "WARNING: metamod version is newer than expected; consider finding a newer version of this module");
+ else
+ LOG_ERROR(PLID, "unexpected version comparison; metavers=%s, mmajor=%d, mminor=%d; plugvers=%s, pmajor=%d, pminor=%d", ifvers, mmajor, mminor, META_INTERFACE_VERSION, pmajor, pminor);
+ }
+
+#ifdef FN_META_QUERY
+ return FN_META_QUERY();
+#endif // FN_META_QUERY
+
+ return 1;
+}
+
+
+C_DLLEXPORT int Meta_Attach(PLUG_LOADTIME now, META_FUNCTIONS *pFunctionTable, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs)
+{
+ if(now > Plugin_info.loadable) {
+ LOG_ERROR(PLID, "Can't load module right now");
+ return(FALSE);
+ }
+ if(!pMGlobals) {
+ LOG_ERROR(PLID, "Meta_Attach called with null pMGlobals");
+ return(FALSE);
+ }
+ gpMetaGlobals=pMGlobals;
+ if(!pFunctionTable) {
+ LOG_ERROR(PLID, "Meta_Attach called with null pFunctionTable");
+ return(FALSE);
+ }
+
+ memcpy(pFunctionTable, &g_MetaFunctions_Table, sizeof(META_FUNCTIONS));
+ gpGamedllFuncs=pGamedllFuncs;
+
+ // Let's go.
+
+#ifdef FN_META_ATTACH
+ FN_META_ATTACH();
+#endif // FN_META_ATTACH
+
+ return TRUE;
+}
+
+C_DLLEXPORT int Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason)
+{
+ if(now > Plugin_info.unloadable && reason != PNL_CMD_FORCED) {
+ LOG_ERROR(PLID, "Can't unload plugin right now");
+ return(FALSE);
+ }
+
+#ifdef FN_META_DETACH
+ return FN_META_DETACH();
+#endif // FN_META_DETACH
+ return TRUE;
+}
+
+
+
+#ifdef __linux__
+// linux prototype
+C_DLLEXPORT void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) {
+
+#else
+#ifdef _MSC_VER
+// MSVC: Simulate __stdcall calling convention
+C_DLLEXPORT __declspec(naked) void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
+{
+ __asm // Prolog
+ {
+ // Save ebp
+ push ebp
+ // Set stack frame pointer
+ mov ebp, esp
+ // Allocate space for local variables
+ // The MSVC compiler gives us the needed size in __LOCAL_SIZE.
+ sub esp, __LOCAL_SIZE
+ // Push registers
+ push ebx
+ push esi
+ push edi
+ }
+#else // _MSC_VER
+#ifdef __GNUC__
+// GCC can also work with this
+C_DLLEXPORT void __stdcall GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
+{
+#else // __GNUC__
+// compiler not known
+#error There is no support (yet) for your compiler. Please use MSVC or GCC compilers or contact the AMX Mod X dev team.
+#endif // __GNUC__
+#endif // _MSC_VER
+#endif // __linux__
+
+ // ** Function core <--
+ memcpy(&g_engfuncs, pengfuncsFromEngine, sizeof(enginefuncs_t));
+ gpGlobals = pGlobals;
+ // NOTE! Have to call logging function _after_ copying into g_engfuncs, so
+ // that g_engfuncs.pfnAlertMessage() can be resolved properly, heh. :)
+ UTIL_LogPrintf("[%s] dev: called: GiveFnptrsToDll\n", Plugin_info.logtag);
+ // --> ** Function core
+
+#ifdef _MSC_VER
+ // Epilog
+ if (sizeof(int*) == 8)
+ { // 64 bit
+ __asm
+ {
+ // Pop registers
+ pop edi
+ pop esi
+ pop ebx
+ // Restore stack frame pointer
+ mov esp, ebp
+ // Restore ebp
+ pop ebp
+ // 2 * sizeof(int*) = 16 on 64 bit
+ ret 16
+ }
+ }
+ else
+ { // 32 bit
+ __asm
+ {
+ // Pop registers
+ pop edi
+ pop esi
+ pop ebx
+ // Restore stack frame pointer
+ mov esp, ebp
+ // Restore ebp
+ pop ebp
+ // 2 * sizeof(int*) = 8 on 32 bit
+ ret 8
+ }
+ }
+#endif // #ifdef _MSC_VER
+}
+
+#endif // #ifdef USE_METAMOD
+
+/************* AMXX Stuff *************/
+
+// *** Globals ***
+// Module info
+static amxx_module_info_s g_ModuleInfo =
+{
+ MODULE_NAME,
+ MODULE_AUTHOR,
+ MODULE_VERSION,
+#ifdef MODULE_RELOAD_ON_MAPCHANGE
+ 1,
+#else // MODULE_RELOAD_ON_MAPCHANGE
+ 0,
+#endif // MODULE_RELOAD_ON_MAPCHANGE
+ MODULE_LOGTAG
+};
+
+// Storage for the requested functions
+PFN_ADD_NATIVES g_fn_AddNatives;
+PFN_BUILD_PATHNAME g_fn_BuildPathname;
+PFN_BUILD_PATHNAME_R g_fn_BuildPathnameR;
+PFN_GET_AMXADDR g_fn_GetAmxAddr;
+PFN_PRINT_SRVCONSOLE g_fn_PrintSrvConsole;
+PFN_GET_MODNAME g_fn_GetModname;
+PFN_GET_AMXSCRIPTNAME g_fn_GetAmxScriptName;
+PFN_GET_AMXSCRIPT g_fn_GetAmxScript;
+PFN_FIND_AMXSCRIPT_BYAMX g_fn_FindAmxScriptByAmx;
+PFN_FIND_AMXSCRIPT_BYNAME g_fn_FindAmxScriptByName;
+PFN_SET_AMXSTRING g_fn_SetAmxString;
+PFN_GET_AMXSTRING g_fn_GetAmxString;
+PFN_GET_AMXSTRINGLEN g_fn_GetAmxStringLen;
+PFN_FORMAT_AMXSTRING g_fn_FormatAmxString;
+PFN_COPY_AMXMEMORY g_fn_CopyAmxMemory;
+PFN_LOG g_fn_Log;
+PFN_LOG_ERROR g_fn_LogErrorFunc;
+PFN_RAISE_AMXERROR g_fn_RaiseAmxError;
+PFN_REGISTER_FORWARD g_fn_RegisterForward;
+PFN_EXECUTE_FORWARD g_fn_ExecuteForward;
+PFN_PREPARE_CELLARRAY g_fn_PrepareCellArray;
+PFN_PREPARE_CHARARRAY g_fn_PrepareCharArray;
+PFN_PREPARE_CELLARRAY_A g_fn_PrepareCellArrayA;
+PFN_PREPARE_CHARARRAY_A g_fn_PrepareCharArrayA;
+PFN_IS_PLAYER_VALID g_fn_IsPlayerValid;
+PFN_GET_PLAYER_NAME g_fn_GetPlayerName;
+PFN_GET_PLAYER_IP g_fn_GetPlayerIP;
+PFN_IS_PLAYER_INGAME g_fn_IsPlayerIngame;
+PFN_IS_PLAYER_BOT g_fn_IsPlayerBot;
+PFN_IS_PLAYER_AUTHORIZED g_fn_IsPlayerAuthorized;
+PFN_GET_PLAYER_TIME g_fn_GetPlayerTime;
+PFN_GET_PLAYER_PLAYTIME g_fn_GetPlayerPlayTime;
+PFN_GET_PLAYER_CURWEAPON g_fn_GetPlayerCurweapon;
+PFN_GET_PLAYER_TEAM g_fn_GetPlayerTeam;
+PFN_GET_PLAYER_TEAMID g_fn_GetPlayerTeamID;
+PFN_GET_PLAYER_DEATHS g_fn_GetPlayerDeaths;
+PFN_GET_PLAYER_MENU g_fn_GetPlayerMenu;
+PFN_GET_PLAYER_KEYS g_fn_GetPlayerKeys;
+PFN_IS_PLAYER_ALIVE g_fn_IsPlayerAlive;
+PFN_GET_PLAYER_FRAGS g_fn_GetPlayerFrags;
+PFN_IS_PLAYER_CONNECTING g_fn_IsPlayerConnecting;
+PFN_IS_PLAYER_HLTV g_fn_IsPlayerHLTV;
+PFN_GET_PLAYER_ARMOR g_fn_GetPlayerArmor;
+PFN_GET_PLAYER_HEALTH g_fn_GetPlayerHealth;
+#ifdef MEMORY_TEST
+PFN_ALLOCATOR g_fn_Allocator;
+PFN_REALLOCATOR g_fn_Reallocator;
+PFN_DEALLOCATOR g_fn_Deallocator;
+#endif
+PFN_AMX_EXEC g_fn_AmxExec;
+PFN_AMX_EXECV g_fn_AmxExecv;
+PFN_AMX_ALLOT g_fn_AmxAllot;
+PFN_AMX_FINDPUBLIC g_fn_AmxFindPublic;
+PFN_LOAD_AMXSCRIPT g_fn_LoadAmxScript;
+PFN_UNLOAD_AMXSCRIPT g_fn_UnloadAmxScript;
+PFN_REAL_TO_CELL g_fn_RealToCell;
+PFN_CELL_TO_REAL g_fn_CellToReal;
+PFN_REGISTER_SPFORWARD g_fn_RegisterSPForward;
+PFN_REGISTER_SPFORWARD_BYNAME g_fn_RegisterSPForwardByName;
+PFN_UNREGISTER_SPFORWARD g_fn_UnregisterSPForward;
+PFN_MERGEDEFINITION_FILE g_fn_MergeDefinition_File;
+PFN_AMX_FINDNATIVE g_fn_AmxFindNative;
+PFN_GETPLAYERFLAGS g_fn_GetPlayerFlags;
+PFN_GET_PLAYER_EDICT g_fn_GetPlayerEdict;
+PFN_FORMAT g_fn_Format;
+PFN_REGISTERFUNCTION g_fn_RegisterFunction;
+PFN_REQ_FNPTR g_fn_RequestFunction;
+PFN_AMX_PUSH g_fn_AmxPush;
+
+// *** Exports ***
+C_DLLEXPORT int AMXX_Query(int *interfaceVersion, amxx_module_info_s *moduleInfo)
+{
+ // check parameters
+ if (!interfaceVersion || !moduleInfo)
+ return AMXX_PARAM;
+
+ // check interface version
+ if (*interfaceVersion != AMXX_INTERFACE_VERSION)
+ {
+ // Tell amxx core our interface version
+ *interfaceVersion = AMXX_INTERFACE_VERSION;
+ return AMXX_IFVERS;
+ }
+
+ // copy module info
+ memcpy(moduleInfo, &g_ModuleInfo, sizeof(amxx_module_info_s));
+
+#ifdef FN_AMXX_QUERY
+ FN_AMXX_QUERY();
+#endif // FN_AMXX_QUERY
+ // Everything ok :)
+ return AMXX_OK;
+}
+
+// request function
+#define REQFUNC(name, fptr, type) if ((fptr = (type)reqFnptrFunc(name)) == 0) return AMXX_FUNC_NOT_PRESENT
+// request optional function
+#define REQFUNC_OPT(name, fptr, type) fptr = (type)reqFnptrFunc(name)
+
+C_DLLEXPORT int AMXX_Attach(PFN_REQ_FNPTR reqFnptrFunc)
+{
+ // Check pointer
+ if (!reqFnptrFunc)
+ return AMXX_PARAM;
+
+ g_fn_RequestFunction = reqFnptrFunc;
+
+ // Req all known functions
+ // Misc
+ REQFUNC("BuildPathname", g_fn_BuildPathname, PFN_BUILD_PATHNAME);
+ REQFUNC("BuildPathnameR", g_fn_BuildPathnameR, PFN_BUILD_PATHNAME_R);
+ REQFUNC("PrintSrvConsole", g_fn_PrintSrvConsole, PFN_PRINT_SRVCONSOLE);
+ REQFUNC("GetModname", g_fn_GetModname, PFN_GET_MODNAME);
+ REQFUNC("Log", g_fn_Log, PFN_LOG);
+ REQFUNC("LogError", g_fn_LogErrorFunc, PFN_LOG_ERROR);
+ REQFUNC("MergeDefinitionFile", g_fn_MergeDefinition_File, PFN_MERGEDEFINITION_FILE);
+ REQFUNC("Format", g_fn_Format, PFN_FORMAT);
+ REQFUNC("RegisterFunction", g_fn_RegisterFunction, PFN_REGISTERFUNCTION);
+
+ // Amx scripts
+ REQFUNC("GetAmxScript", g_fn_GetAmxScript, PFN_GET_AMXSCRIPT);
+ REQFUNC("FindAmxScriptByAmx", g_fn_FindAmxScriptByAmx, PFN_FIND_AMXSCRIPT_BYAMX);
+ REQFUNC("FindAmxScriptByName", g_fn_FindAmxScriptByName, PFN_FIND_AMXSCRIPT_BYNAME);
+ REQFUNC("LoadAmxScript", g_fn_LoadAmxScript, PFN_LOAD_AMXSCRIPT);
+ REQFUNC("UnloadAmxScript", g_fn_UnloadAmxScript, PFN_UNLOAD_AMXSCRIPT);
+ REQFUNC("GetAmxScriptName", g_fn_GetAmxScriptName, PFN_GET_AMXSCRIPTNAME);
+
+ // String / mem in amx scripts support
+ REQFUNC("SetAmxString", g_fn_SetAmxString, PFN_SET_AMXSTRING);
+ REQFUNC("GetAmxString", g_fn_GetAmxString, PFN_GET_AMXSTRING);
+ REQFUNC("GetAmxStringLen", g_fn_GetAmxStringLen, PFN_GET_AMXSTRINGLEN);
+ REQFUNC("FormatAmxString", g_fn_FormatAmxString, PFN_FORMAT_AMXSTRING);
+ REQFUNC("CopyAmxMemory", g_fn_CopyAmxMemory, PFN_COPY_AMXMEMORY);
+ REQFUNC("GetAmxAddr", g_fn_GetAmxAddr, PFN_GET_AMXADDR);
+
+ REQFUNC("amx_Exec", g_fn_AmxExec, PFN_AMX_EXEC);
+ REQFUNC("amx_Execv", g_fn_AmxExecv, PFN_AMX_EXECV);
+ REQFUNC("amx_FindPublic", g_fn_AmxFindPublic, PFN_AMX_FINDPUBLIC);
+ REQFUNC("amx_Allot", g_fn_AmxAllot, PFN_AMX_ALLOT);
+ REQFUNC("amx_FindNative", g_fn_AmxFindNative, PFN_AMX_FINDNATIVE);
+
+ // Natives / Forwards
+ REQFUNC("AddNatives", g_fn_AddNatives, PFN_ADD_NATIVES);
+ REQFUNC("RaiseAmxError", g_fn_RaiseAmxError, PFN_RAISE_AMXERROR);
+ REQFUNC("RegisterForward", g_fn_RegisterForward, PFN_REGISTER_FORWARD);
+ REQFUNC("RegisterSPForward", g_fn_RegisterSPForward, PFN_REGISTER_SPFORWARD);
+ REQFUNC("RegisterSPForwardByName", g_fn_RegisterSPForwardByName, PFN_REGISTER_SPFORWARD_BYNAME);
+ REQFUNC("UnregisterSPForward", g_fn_UnregisterSPForward, PFN_UNREGISTER_SPFORWARD);
+ REQFUNC("ExecuteForward", g_fn_ExecuteForward, PFN_EXECUTE_FORWARD);
+ REQFUNC("PrepareCellArray", g_fn_PrepareCellArray, PFN_PREPARE_CELLARRAY);
+ REQFUNC("PrepareCharArray", g_fn_PrepareCharArray, PFN_PREPARE_CHARARRAY);
+ REQFUNC("PrepareCellArrayA", g_fn_PrepareCellArrayA, PFN_PREPARE_CELLARRAY_A);
+ REQFUNC("PrepareCharArrayA", g_fn_PrepareCharArrayA, PFN_PREPARE_CHARARRAY_A);
+ // Player
+ REQFUNC("IsPlayerValid", g_fn_IsPlayerValid, PFN_IS_PLAYER_VALID);
+ REQFUNC("GetPlayerName", g_fn_GetPlayerName, PFN_GET_PLAYER_NAME);
+ REQFUNC("GetPlayerIP", g_fn_GetPlayerIP, PFN_GET_PLAYER_IP);
+ REQFUNC("IsPlayerInGame", g_fn_IsPlayerIngame, PFN_IS_PLAYER_INGAME);
+ REQFUNC("IsPlayerBot", g_fn_IsPlayerBot, PFN_IS_PLAYER_BOT);
+ REQFUNC("IsPlayerAuthorized", g_fn_IsPlayerAuthorized, PFN_IS_PLAYER_AUTHORIZED);
+ REQFUNC("GetPlayerTime", g_fn_GetPlayerTime, PFN_GET_PLAYER_TIME);
+ REQFUNC("GetPlayerPlayTime", g_fn_GetPlayerPlayTime, PFN_GET_PLAYER_PLAYTIME);
+ REQFUNC("GetPlayerCurweapon", g_fn_GetPlayerCurweapon, PFN_GET_PLAYER_CURWEAPON);
+ REQFUNC("GetPlayerTeamID", g_fn_GetPlayerTeamID, PFN_GET_PLAYER_TEAMID);
+ REQFUNC("GetPlayerTeam",g_fn_GetPlayerTeam, PFN_GET_PLAYER_TEAM);
+ REQFUNC("GetPlayerDeaths", g_fn_GetPlayerDeaths, PFN_GET_PLAYER_DEATHS);
+ REQFUNC("GetPlayerMenu", g_fn_GetPlayerMenu, PFN_GET_PLAYER_MENU);
+ REQFUNC("GetPlayerKeys", g_fn_GetPlayerKeys, PFN_GET_PLAYER_KEYS);
+ REQFUNC("IsPlayerAlive", g_fn_IsPlayerAlive, PFN_IS_PLAYER_ALIVE);
+ REQFUNC("GetPlayerFrags", g_fn_GetPlayerFrags, PFN_GET_PLAYER_FRAGS);
+ REQFUNC("IsPlayerConnecting", g_fn_IsPlayerConnecting, PFN_IS_PLAYER_CONNECTING);
+ REQFUNC("IsPlayerHLTV", g_fn_IsPlayerHLTV, PFN_IS_PLAYER_HLTV);
+ REQFUNC("GetPlayerArmor", g_fn_GetPlayerArmor, PFN_GET_PLAYER_ARMOR);
+ REQFUNC("GetPlayerHealth", g_fn_GetPlayerHealth, PFN_GET_PLAYER_HEALTH);
+ REQFUNC("GetPlayerFlags", g_fn_GetPlayerFlags, PFN_GETPLAYERFLAGS);
+ REQFUNC("GetPlayerEdict", g_fn_GetPlayerEdict, PFN_GET_PLAYER_EDICT);
+ REQFUNC("amx_Push", g_fn_AmxPush, PFN_AMX_PUSH);
+
+#ifdef MEMORY_TEST
+ // Memory
+ REQFUNC_OPT("Allocator", g_fn_Allocator, PFN_ALLOCATOR);
+ REQFUNC_OPT("Reallocator", g_fn_Reallocator, PFN_REALLOCATOR);
+ REQFUNC_OPT("Deallocator", g_fn_Deallocator, PFN_DEALLOCATOR);
+#endif
+
+ REQFUNC("CellToReal", g_fn_CellToReal, PFN_CELL_TO_REAL);
+ REQFUNC("RealToCell", g_fn_RealToCell, PFN_REAL_TO_CELL);
+
+#ifdef FN_AMXX_ATTACH
+ FN_AMXX_ATTACH();
+#endif // FN_AMXX_ATACH
+
+ return AMXX_OK;
+}
+
+C_DLLEXPORT int AMXX_Detach()
+{
+#ifdef FN_AMXX_DETACH
+ FN_AMXX_DETACH();
+#endif // FN_AMXX_DETACH
+
+ return AMXX_OK;
+}
+
+C_DLLEXPORT int AMXX_PluginsLoaded()
+{
+#ifdef FN_AMXX_PLUGINSLOADED
+ FN_AMXX_PLUGINSLOADED();
+#endif // FN_AMXX_PLUGINSLOADED
+ return AMXX_OK;
+}
+
+// Advanced MF functions
+void MF_Log(const char *fmt, ...)
+{
+ // :TODO: Overflow possible here
+ char msg[3072];
+ va_list arglst;
+ va_start(arglst, fmt);
+ vsprintf(msg, fmt, arglst);
+ va_end(arglst);
+
+ g_fn_Log("[%s] %s", MODULE_LOGTAG, msg);
+}
+
+void MF_LogError(AMX *amx, int err, const char *fmt, ...)
+{
+ // :TODO: Overflow possible here
+ char msg[3072];
+ va_list arglst;
+ va_start(arglst, fmt);
+ vsprintf(msg, fmt, arglst);
+ va_end(arglst);
+
+ g_fn_LogErrorFunc(amx, err, "[%s] %s", MODULE_LOGTAG, msg);
+}
+
+
+#ifdef _DEBUG
+// validate macros
+// Makes sure compiler reports errors when macros are invalid
+void ValidateMacros_DontCallThis_Smiley()
+{
+ MF_BuildPathname("str", "str", 0);
+ MF_BuildPathnameR(NULL, 0, "%d", 0);
+ MF_FormatAmxString(NULL, 0, 0, NULL);
+ MF_GetAmxAddr(NULL, 0);
+ MF_PrintSrvConsole("str", "str", 0);
+ MF_GetModname();
+ MF_GetScriptName(0);
+ MF_GetScriptAmx(0);
+ MF_FindScriptByAmx(NULL);
+ MF_FindScriptByName("str");
+ MF_SetAmxString(NULL, 0, "str", 0);
+ MF_GetAmxString(NULL, 0, 0, 0);
+ MF_GetAmxStringLen(NULL);
+ MF_CopyAmxMemory(NULL, NULL, 0);
+ MF_Log("str", "str", 0);
+ MF_LogError(NULL, 0, NULL);
+ MF_RaiseAmxError(NULL, 0);
+ MF_RegisterForward("str", (ForwardExecType)0, 0, 0, 0);
+ MF_ExecuteForward(0, 0, 0);
+ MF_PrepareCellArray(NULL, 0);
+ MF_PrepareCharArray(NULL, 0);
+ MF_PrepareCellArrayA(NULL, 0, true);
+ MF_PrepareCharArrayA(NULL, 0, true);
+ MF_IsPlayerValid(0);
+ MF_GetPlayerName(0);
+ MF_GetPlayerIP(0);
+ MF_IsPlayerIngame(0);
+ MF_IsPlayerBot(0);
+ MF_IsPlayerAuthorized(0);
+ MF_GetPlayerTime(0);
+ MF_GetPlayerPlayTime(0);
+ MF_GetPlayerCurweapon(0);
+ MF_GetPlayerTeamID(0);
+ MF_GetPlayerTeam(0);
+ MF_GetPlayerDeaths(0);
+ MF_GetPlayerMenu(0);
+ MF_GetPlayerKeys(0);
+ MF_IsPlayerAlive(0);
+ MF_GetPlayerFrags(0);
+ MF_IsPlayerConnecting(0);
+ MF_IsPlayerHLTV(0);
+ MF_GetPlayerArmor(0);
+ MF_GetPlayerHealth(0);
+ MF_AmxExec(0, 0, 0);
+ MF_AmxExecv(0, 0, 0, 0, 0);
+ MF_AmxFindPublic(0, 0, 0);
+ MF_AmxAllot(0, 0, 0, 0);
+ MF_LoadAmxScript(0, 0, 0, 0, 0);
+ MF_UnloadAmxScript(0, 0);
+ MF_RegisterSPForward(0, 0, 0, 0, 0, 0);
+ MF_RegisterSPForwardByName(0, 0, 0, 0, 0, 0);
+ MF_UnregisterSPForward(0);
+ MF_GetPlayerFrags(0);
+ MF_GetPlayerEdict(0);
+ MF_Format("", 4, "str");
+ MF_RegisterFunction(NULL, "");
+}
+#endif
+
+#ifdef MEMORY_TEST
+
+/************* MEMORY *************/
+// undef all defined macros
+#undef new
+#undef delete
+#undef malloc
+#undef calloc
+#undef realloc
+#undef free
+
+const unsigned int m_alloc_unknown = 0;
+const unsigned int m_alloc_new = 1;
+const unsigned int m_alloc_new_array = 2;
+const unsigned int m_alloc_malloc = 3;
+const unsigned int m_alloc_calloc = 4;
+const unsigned int m_alloc_realloc = 5;
+const unsigned int m_alloc_delete = 6;
+const unsigned int m_alloc_delete_array = 7;
+const unsigned int m_alloc_free = 8;
+
+const char *g_Mem_CurrentFilename = "??";
+int g_Mem_CurrentLine = 0;
+const char *g_Mem_CurrentFunc = "??";
+
+const char *Mem_MakeSourceFile(const char *sourceFile)
+{
+ static char buffer[512];
+ static size_t pos = 0;
+ if (!pos)
+ {
+ // init
+ buffer[0] = '[';
+ strcpy(buffer + 1, MODULE_NAME);
+ pos = strlen(MODULE_NAME) + 1;
+ buffer[pos++] = ']';
+ }
+
+ // convert from absolute path to [modulename]filename
+ const char *ptr = strrchr(sourceFile, '\\');
+ if (ptr)
+ ptr++;
+ else
+ {
+ ptr = strrchr(sourceFile, '/');
+ if (ptr)
+ ptr++;
+ else
+ ptr = sourceFile;
+ }
+ strcpy(buffer + pos, ptr);
+ return buffer;
+}
+
+void Mem_SetOwner(const char *filename, int line, const char *function)
+{
+ g_Mem_CurrentFilename = filename;
+ g_Mem_CurrentLine = line;
+ g_Mem_CurrentFunc = function;
+}
+
+void Mem_ResetGlobals()
+{
+ Mem_SetOwner("??", 0, "??");
+}
+
+// raw (re/de)allocators
+void * Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+ const unsigned int allocationType, const size_t reportedSize)
+{
+ if (g_fn_Allocator)
+ return g_fn_Allocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, allocationType, reportedSize);
+ else
+ return malloc(reportedSize);
+}
+
+void * Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+ const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress)
+{
+ if (g_fn_Reallocator)
+ return g_fn_Reallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, reallocationType, reportedSize, reportedAddress);
+ else
+ return realloc(reportedAddress, reportedSize);
+}
+
+void Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+ const unsigned int deallocationType, void *reportedAddress)
+{
+ // If you you get user breakpoint here, something failed :)
+ // - invalid pointer
+ // - alloc type mismatch ( for example
+ // char *a = new char[5]; delete char;
+ // )
+ // - The allocation unit is damaged (for example
+ // char *a = new char[5]; a[6] = 8;
+ // )
+ // - break on dealloc flag set (somehow)
+
+ if (g_fn_Deallocator)
+ g_fn_Deallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, deallocationType, reportedAddress);
+ else
+ free(reportedAddress);
+}
+
+// new and delete operators
+void *operator new(size_t reportedSize)
+{
+ if (reportedSize == 0)
+ reportedSize = 1;
+ void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize);
+ // :TODO: Handler support ?
+ if (ptr)
+ return ptr;
+
+ // allocation failed
+ return NULL;
+}
+
+void *operator new[](size_t reportedSize)
+{
+ if (reportedSize == 0)
+ reportedSize = 1;
+ void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize);
+ // :TODO: Handler support ?
+ if (ptr)
+ return ptr;
+
+ // allocation failed
+ return NULL;
+}
+
+// Microsoft memory tracking operators
+void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine)
+{
+ if (reportedSize == 0)
+ reportedSize = 1;
+ void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize);
+ // :TODO: Handler support ?
+ if (ptr)
+ return ptr;
+
+ // allocation failed
+ return NULL;
+}
+void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine)
+{
+ if (reportedSize == 0)
+ reportedSize = 1;
+ void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize);
+ // :TODO: Handler support ?
+ if (ptr)
+ return ptr;
+
+ // allocation failed
+ return NULL;
+}
+
+void operator delete(void *reportedAddress)
+{
+ if (!reportedAddress)
+ return;
+
+ Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete, reportedAddress);
+}
+
+void operator delete[](void *reportedAddress)
+{
+ if (!reportedAddress)
+ return;
+
+ Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete_array, reportedAddress);
+}
+
+#else
+
+#if !defined NO_ALLOC_OVERRIDES && !defined MEMORY_TEST && !defined WIN32
+void * ::operator new(size_t size) {
+ return(calloc(1, size));
+}
+
+void * ::operator new[](size_t size) {
+ return(calloc(1, size));
+}
+
+void ::operator delete(void * ptr) {
+ if(ptr)
+ free(ptr);
+}
+
+void ::operator delete[](void * ptr) {
+ if(ptr)
+ free(ptr);
+}
+#endif
+
+#endif //MEMORY_TEST
+
+/************* stuff from dlls/util.cpp *************/
+// must come here because cbase.h declares it's own operator new
+
+#ifdef USE_METAMOD
+
+// Selected portions of dlls/util.cpp from SDK 2.1.
+// Functions copied from there as needed...
+// And modified to avoid buffer overflows (argh).
+
+/***
+*
+* Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*
+* This product contains software technology licensed from Id
+* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
+* All Rights Reserved.
+*
+* Use, distribution, and modification of this source code and/or resulting
+* object code is restricted to non-commercial enhancements to products from
+* Valve LLC. All other use, distribution, or modification is prohibited
+* without written permission from Valve LLC.
+*
+****/
+/*
+
+===== util.cpp ========================================================
+
+ Utility code. Really not optional after all.
+
+*/
+
+#include
+#include "sdk_util.h"
+#include
+
+#include // for strncpy(), etc
+
+#include "osdep.h" // win32 vsnprintf, etc
+
+char* UTIL_VarArgs( char *format, ... )
+{
+ va_list argptr;
+ static char string[1024];
+
+ va_start (argptr, format);
+ vsnprintf (string, sizeof(string), format, argptr);
+ va_end (argptr);
+
+ return string;
+}
+
+
+//=========================================================
+// UTIL_LogPrintf - Prints a logged message to console.
+// Preceded by LOG: ( timestamp ) < message >
+//=========================================================
+void UTIL_LogPrintf( char *fmt, ... )
+{
+ va_list argptr;
+ static char string[1024];
+
+ va_start ( argptr, fmt );
+ vsnprintf ( string, sizeof(string), fmt, argptr );
+ va_end ( argptr );
+
+ // Print to server console
+ ALERT( at_logged, "%s", string );
+}
+
+
+void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms,
+ const char *pMessage)
+{
+ if ( !pEntity )
+ return;
+
+ MESSAGE_BEGIN( MSG_ONE, SVC_TEMPENTITY, NULL, ENT(pEntity->pev) );
+ WRITE_BYTE( TE_TEXTMESSAGE );
+ WRITE_BYTE( textparms.channel & 0xFF );
+
+ WRITE_SHORT( FixedSigned16( textparms.x, 1<<13 ) );
+ WRITE_SHORT( FixedSigned16( textparms.y, 1<<13 ) );
+ WRITE_BYTE( textparms.effect );
+
+ WRITE_BYTE( textparms.r1 );
+ WRITE_BYTE( textparms.g1 );
+ WRITE_BYTE( textparms.b1 );
+ WRITE_BYTE( textparms.a1 );
+
+ WRITE_BYTE( textparms.r2 );
+ WRITE_BYTE( textparms.g2 );
+ WRITE_BYTE( textparms.b2 );
+ WRITE_BYTE( textparms.a2 );
+
+ WRITE_SHORT( FixedUnsigned16( textparms.fadeinTime, 1<<8 ) );
+ WRITE_SHORT( FixedUnsigned16( textparms.fadeoutTime, 1<<8 ) );
+ WRITE_SHORT( FixedUnsigned16( textparms.holdTime, 1<<8 ) );
+
+ if ( textparms.effect == 2 )
+ WRITE_SHORT( FixedUnsigned16( textparms.fxTime, 1<<8 ) );
+
+ if ( strlen( pMessage ) < 512 )
+ {
+ WRITE_STRING( pMessage );
+ }
+ else
+ {
+ char tmp[512];
+ strncpy( tmp, pMessage, 511 );
+ tmp[511] = 0;
+ WRITE_STRING( tmp );
+ }
+ MESSAGE_END();
+}
+
+short FixedSigned16( float value, float scale )
+{
+ int output;
+
+ output = (int) (value * scale);
+
+ if ( output > 32767 )
+ output = 32767;
+
+ if ( output < -32768 )
+ output = -32768;
+
+ return (short)output;
+}
+
+unsigned short FixedUnsigned16( float value, float scale )
+{
+ int output;
+
+ output = (int) (value * scale);
+ if ( output < 0 )
+ output = 0;
+ if ( output > 0xFFFF )
+ output = 0xFFFF;
+
+ return (unsigned short)output;
+}
+#endif // USE_METAMOD
diff --git a/dlls/arrayx/amxxmodule.h b/dlls/arrayx/amxxmodule.h
new file mode 100644
index 00000000..0a000d20
--- /dev/null
+++ b/dlls/arrayx/amxxmodule.h
@@ -0,0 +1,2241 @@
+/*
+ * AMX Mod X Module Interface Functions
+ * This file may be freely used
+*/
+
+// prevent double include
+#ifndef __AMXXMODULE_H__
+#define __AMXXMODULE_H__
+
+// config
+#include "moduleconfig.h"
+
+// metamod include files
+#ifdef USE_METAMOD
+#include
+#include
+#include "osdep.h"
+#endif // #ifdef USE_METAMOD
+
+// DLL Export
+#undef DLLEXPORT
+#ifndef __linux__
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#define LINUX
+#endif
+
+#undef C_DLLEXPORT
+#define C_DLLEXPORT extern "C" DLLEXPORT
+
+// ***** AMXX stuff *****
+
+// module interface version was 1
+// 2 - added logtag to struct (amxx1.1-rc1)
+// 3 - added new tagAMX structure (amxx1.5)
+#define AMXX_INTERFACE_VERSION 3
+
+// amxx module info
+struct amxx_module_info_s
+{
+ const char *name;
+ const char *author;
+ const char *version;
+ int reload; // reload on mapchange when nonzero
+ const char *logtag; // added in version 2
+};
+
+// return values from functions called by amxx
+#define AMXX_OK 0 /* no error */
+#define AMXX_IFVERS 1 /* interface version */
+#define AMXX_PARAM 2 /* Invalid parameter */
+#define AMXX_FUNC_NOT_PRESENT 3 /* Function not present */
+
+// *** Small stuff ***
+// The next section is copied from the amx.h file
+// Copyright (c) ITB CompuPhase, 1997-2005
+
+#if defined HAVE_STDINT_H
+ #include
+#else
+ #if defined __LCC__ || defined __DMC__ || defined LINUX
+ #if defined HAVE_INTTYPES_H
+ #include
+ #else
+ #include
+ #endif
+ #elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
+ /* The ISO C99 defines the int16_t and int_32t types. If the compiler got
+ * here, these types are probably undefined.
+ */
+ #if defined __MACH__
+ #include
+ typedef unsigned short int uint16_t;
+ typedef unsigned long int uint32_t;
+ #elif defined __FreeBSD__
+ #include
+ #else
+ typedef short int int16_t;
+ typedef unsigned short int uint16_t;
+ #if defined SN_TARGET_PS2
+ typedef int int32_t;
+ typedef unsigned int uint32_t;
+ #else
+ typedef long int int32_t;
+ typedef unsigned long int uint32_t;
+ #endif
+ #if defined __WIN32__ || defined _WIN32 || defined WIN32
+ typedef __int64 int64_t;
+ typedef unsigned __int64 uint64_t;
+ #define HAVE_I64
+ #elif defined __GNUC__
+ typedef long long int64_t;
+ typedef unsigned long long uint64_t;
+ #define HAVE_I64
+ #endif
+ #endif
+ #endif
+ #define HAVE_STDINT_H
+#endif
+#if defined _LP64 || defined WIN64 || defined _WIN64
+ #if !defined __64BIT__
+ #define __64BIT__
+ #endif
+#endif
+
+/* calling convention for native functions */
+#if !defined AMX_NATIVE_CALL
+ #define AMX_NATIVE_CALL
+#endif
+/* calling convention for all interface functions and callback functions */
+#if !defined AMXAPI
+ #if defined STDECL
+ #define AMXAPI __stdcall
+ #elif defined CDECL
+ #define AMXAPI __cdecl
+ #else
+ #define AMXAPI
+ #endif
+#endif
+#if !defined AMXEXPORT
+ #define AMXEXPORT
+#endif
+
+#if !defined PAWN_CELL_SIZE
+ #define PAWN_CELL_SIZE 32 /* by default, use 32-bit cells */
+#endif
+#if PAWN_CELL_SIZE==16
+ typedef uint16_t ucell;
+ typedef int16_t cell;
+#elif PAWN_CELL_SIZE==32
+ typedef uint32_t ucell;
+ typedef int32_t cell;
+#define REAL float
+#elif PAWN_CELL_SIZE==64
+ typedef uint64_t ucell;
+ typedef int64_t cell;
+#define REAL double
+#else
+ #error Unsupported cell size (PAWN_CELL_SIZE)
+#endif
+
+#define UNPACKEDMAX ((1 << (sizeof(cell)-1)*8) - 1)
+#define UNLIMITED (~1u >> 1)
+
+struct tagAMX;
+typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params);
+typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index,
+ cell *result, cell *params);
+typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
+#if !defined _FAR
+ #define _FAR
+#endif
+
+#if defined _MSC_VER
+ #pragma warning(disable:4103) /* disable warning message 4103 that complains
+ * about pragma pack in a header file */
+ #pragma warning(disable:4100) /* "'%$S' : unreferenced formal parameter" */
+#endif
+
+
+/* Some compilers do not support the #pragma align, which should be fine. Some
+ * compilers give a warning on unknown #pragmas, which is not so fine...
+ */
+#if (defined SN_TARGET_PS2 || defined __GNUC__) && !defined AMX_NO_ALIGN
+ #define AMX_NO_ALIGN
+#endif
+
+#if defined __GNUC__
+ #define PACKED __attribute__((packed))
+#else
+ #define PACKED
+#endif
+
+#if !defined AMX_NO_ALIGN
+ #if defined LINUX || defined __FreeBSD__
+ #pragma pack(1) /* structures must be packed (byte-aligned) */
+ #elif defined MACOS && defined __MWERKS__
+ #pragma options align=mac68k
+ #else
+ #pragma pack(push)
+ #pragma pack(1) /* structures must be packed (byte-aligned) */
+ #if defined __TURBOC__
+ #pragma option -a- /* "pack" pragma for older Borland compilers */
+ #endif
+ #endif
+#endif
+
+typedef struct {
+ const char _FAR *name PACKED;
+ AMX_NATIVE func PACKED;
+} AMX_NATIVE_INFO;
+
+#define AMX_USERNUM 4
+
+/* The AMX structure is the internal structure for many functions. Not all
+ * fields are valid at all times; many fields are cached in local variables.
+ */
+typedef struct tagAMX {
+ unsigned char _FAR *base PACKED; /* points to the AMX header plus the code, optionally also the data */
+ unsigned char _FAR *data PACKED; /* points to separate data+stack+heap, may be NULL */
+ AMX_CALLBACK callback PACKED;
+ AMX_DEBUG debug PACKED; /* debug callback */
+ /* for external functions a few registers must be accessible from the outside */
+ cell cip PACKED; /* instruction pointer: relative to base + amxhdr->cod */
+ cell frm PACKED; /* stack frame base: relative to base + amxhdr->dat */
+ cell hea PACKED; /* top of the heap: relative to base + amxhdr->dat */
+ cell hlw PACKED; /* bottom of the heap: relative to base + amxhdr->dat */
+ cell stk PACKED; /* stack pointer: relative to base + amxhdr->dat */
+ cell stp PACKED; /* top of the stack: relative to base + amxhdr->dat */
+ int flags PACKED; /* current status, see amx_Flags() */
+ /* user data */
+ long usertags[AMX_USERNUM] PACKED;
+ //okay userdata[3] in AMX Mod X is for the CPlugin * pointer
+ //we're also gonna set userdata[2] to a special debug structure
+ void _FAR *userdata[AMX_USERNUM] PACKED;
+ /* native functions can raise an error */
+ int error PACKED;
+ /* passing parameters requires a "count" field */
+ int paramcount;
+ /* the sleep opcode needs to store the full AMX status */
+ cell pri PACKED;
+ cell alt PACKED;
+ cell reset_stk PACKED;
+ cell reset_hea PACKED;
+ cell sysreq_d PACKED; /* relocated address/value for the SYSREQ.D opcode */
+ /* support variables for the JIT */
+ int reloc_size PACKED; /* required temporary buffer for relocations */
+ long code_size PACKED; /* estimated memory footprint of the native code */
+} PACKED AMX;
+
+enum {
+ AMX_ERR_NONE,
+ /* reserve the first 15 error codes for exit codes of the abstract machine */
+ AMX_ERR_EXIT, /* forced exit */
+ AMX_ERR_ASSERT, /* assertion failed */
+ AMX_ERR_STACKERR, /* stack/heap collision */
+ AMX_ERR_BOUNDS, /* index out of bounds */
+ AMX_ERR_MEMACCESS, /* invalid memory access */
+ AMX_ERR_INVINSTR, /* invalid instruction */
+ AMX_ERR_STACKLOW, /* stack underflow */
+ AMX_ERR_HEAPLOW, /* heap underflow */
+ AMX_ERR_CALLBACK, /* no callback, or invalid callback */
+ AMX_ERR_NATIVE, /* native function failed */
+ AMX_ERR_DIVIDE, /* divide by zero */
+ AMX_ERR_SLEEP, /* go into sleepmode - code can be restarted */
+ AMX_ERR_INVSTATE, /* invalid state for this access */
+
+ AMX_ERR_MEMORY = 16, /* out of memory */
+ AMX_ERR_FORMAT, /* invalid file format */
+ AMX_ERR_VERSION, /* file is for a newer version of the AMX */
+ AMX_ERR_NOTFOUND, /* function not found */
+ AMX_ERR_INDEX, /* invalid index parameter (bad entry point) */
+ AMX_ERR_DEBUG, /* debugger cannot run */
+ AMX_ERR_INIT, /* AMX not initialized (or doubly initialized) */
+ AMX_ERR_USERDATA, /* unable to set user data field (table full) */
+ AMX_ERR_INIT_JIT, /* cannot initialize the JIT */
+ AMX_ERR_PARAMS, /* parameter error */
+ AMX_ERR_DOMAIN, /* domain error, expression result does not fit in range */
+};
+
+#if !defined AMX_NO_ALIGN
+ #if defined __linux__
+ #pragma pack() /* reset default packing */
+ #else
+ #pragma pack(pop) /* reset previous packing */
+ #endif
+#endif
+
+
+// ***** declare functions *****
+
+#ifdef USE_METAMOD
+void UTIL_LogPrintf( char *fmt, ... );
+void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, const char *pMessage);
+short FixedSigned16( float value, float scale );
+unsigned short FixedUnsigned16( float value, float scale );
+
+#ifdef FN_META_QUERY
+void FN_META_QUERY(void);
+#endif // FN_META_QUERY
+
+#ifdef FN_META_ATTACH
+void FN_META_ATTACH(void);
+#endif // FN_META_ATTACH
+
+#ifdef FN_META_DETACH
+void FN_META_DETACH(void);
+#endif // FN_META_DETACH
+
+
+
+
+
+#ifdef FN_GameDLLInit
+void FN_GameDLLInit(void);
+#endif // FN_GameDLLInit
+
+#ifdef FN_DispatchSpawn
+int FN_DispatchSpawn(edict_t *pent);
+#endif // FN_DispatchSpawn
+
+#ifdef FN_DispatchThink
+void FN_DispatchThink(edict_t *pent);
+#endif // FN_DispatchThink
+
+#ifdef FN_DispatchUse
+void FN_DispatchUse(edict_t *pentUser, edict_t *pentOther);
+#endif // FN_DispatchUse
+
+#ifdef FN_DispatchTouch
+void FN_DispatchTouch(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_DispatchTouch
+
+#ifdef FN_DispatchBlocked
+void FN_DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther);
+#endif // FN_DispatchBlocked
+
+#ifdef FN_DispatchKeyValue
+void FN_DispatchKeyValue(edict_t *pentKeyvalue, KeyValueData *pkvd);
+#endif // FN_DispatchKeyValue
+
+#ifdef FN_DispatchSave
+void FN_DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData);
+#endif // FN_DispatchSave
+
+#ifdef FN_DispatchRestore
+int FN_DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity);
+#endif // FN_DispatchRestore
+
+#ifdef FN_DispatchObjectCollsionBox
+void FN_DispatchObjectCollsionBox(edict_t *pent);
+#endif // FN_DispatchObjectCollsionBox
+
+#ifdef FN_SaveWriteFields
+void FN_SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveWriteFields
+
+#ifdef FN_SaveReadFields
+void FN_SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveReadFields
+
+#ifdef FN_SaveGlobalState
+void FN_SaveGlobalState(SAVERESTOREDATA *pSaveData);
+#endif // FN_SaveGlobalState
+
+#ifdef FN_RestoreGlobalState
+void FN_RestoreGlobalState(SAVERESTOREDATA *pSaveData);
+#endif // FN_RestoreGlobalState
+
+#ifdef FN_ResetGlobalState
+void FN_ResetGlobalState(void);
+#endif // FN_ResetGlobalState
+
+#ifdef FN_ClientConnect
+BOOL FN_ClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]);
+#endif // FN_ClientConnect
+
+#ifdef FN_ClientDisconnect
+void FN_ClientDisconnect(edict_t *pEntity);
+#endif // FN_ClientDisconnect
+
+#ifdef FN_ClientKill
+void FN_ClientKill(edict_t *pEntity);
+#endif // FN_ClientKill
+
+#ifdef FN_ClientPutInServer
+void FN_ClientPutInServer(edict_t *pEntity);
+#endif // FN_ClientPutInServer
+
+#ifdef FN_ClientCommand
+void FN_ClientCommand(edict_t *pEntity);
+#endif // FN_ClientCommand
+
+#ifdef FN_ClientUserInfoChanged
+void FN_ClientUserInfoChanged(edict_t *pEntity, char *infobuffer);
+#endif // FN_ClientUserInfoChanged
+
+#ifdef FN_ServerActivate
+void FN_ServerActivate(edict_t *pEdictList, int edictCount, int clientMax);
+#endif // FN_ServerActivate
+
+#ifdef FN_ServerDeactivate
+void FN_ServerDeactivate(void);
+#endif // FN_ServerDeactivate
+
+#ifdef FN_PlayerPreThink
+void FN_PlayerPreThink(edict_t *pEntity);
+#endif // FN_PlayerPreThink
+
+#ifdef FN_PlayerPostThink
+void FN_PlayerPostThink(edict_t *pEntity);
+#endif // FN_PlayerPostThink
+
+#ifdef FN_StartFrame
+void FN_StartFrame(void);
+#endif // FN_StartFrame
+
+#ifdef FN_ParmsNewLevel
+void FN_ParmsNewLevel(void);
+#endif // FN_ParmsNewLevel
+
+#ifdef FN_ParmsChangeLevel
+void FN_ParmsChangeLevel(void);
+#endif // FN_ParmsChangeLevel
+
+#ifdef FN_GetGameDescription
+const char *FN_GetGameDescription(void);
+#endif // FN_GetGameDescription
+
+#ifdef FN_PlayerCustomization
+void FN_PlayerCustomization(edict_t *pEntity, customization_t *pCust);
+#endif // FN_PlayerCustomization
+
+#ifdef FN_SpectatorConnect
+void FN_SpectatorConnect(edict_t *pEntity);
+#endif // FN_SpectatorConnect
+
+#ifdef FN_SpectatorDisconnect
+void FN_SpectatorDisconnect(edict_t *pEntity);
+#endif // FN_SpectatorDisconnect
+
+#ifdef FN_SpectatorThink
+void FN_SpectatorThink(edict_t *pEntity);
+#endif // FN_SpectatorThink
+
+#ifdef FN_Sys_Error
+void FN_Sys_Error(const char *error_string);
+#endif // FN_Sys_Error
+
+#ifdef FN_PM_Move
+void FN_PM_Move(struct playermove_s *ppmove, int server);
+#endif // FN_PM_Move
+
+#ifdef FN_PM_Init
+void FN_PM_Init(struct playermove_s *ppmove);
+#endif // FN_PM_Init
+
+#ifdef FN_PM_FindTextureType
+char FN_PM_FindTextureType(char *name);
+#endif // FN_PM_FindTextureType
+
+#ifdef FN_SetupVisibility
+void FN_SetupVisibility(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas);
+#endif // FN_SetupVisibility
+
+#ifdef FN_UpdateClientData
+void FN_UpdateClientData(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd);
+#endif // FN_UpdateClientData
+
+#ifdef FN_AddToFullPack
+int FN_AddToFullPack(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet);
+#endif // FN_AddToFullPack
+
+#ifdef FN_CreateBaseline
+void FN_CreateBaseline(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs);
+#endif // FN_CreateBaseline
+
+#ifdef FN_RegisterEncoders
+void FN_RegisterEncoders(void);
+#endif // FN_RegisterEncoders
+
+#ifdef FN_GetWeaponData
+int FN_GetWeaponData(struct edict_s *player, struct weapon_data_s *info);
+#endif // FN_GetWeaponData
+
+#ifdef FN_CmdStart
+void FN_CmdStart(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed);
+#endif // FN_CmdStart
+
+#ifdef FN_CmdEnd
+void FN_CmdEnd(const edict_t *player);
+#endif // FN_CmdEnd
+
+#ifdef FN_ConnectionlessPacket
+int FN_ConnectionlessPacket(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size);
+#endif // FN_ConnectionlessPacket
+
+#ifdef FN_GetHullBounds
+int FN_GetHullBounds(int hullnumber, float *mins, float *maxs);
+#endif // FN_GetHullBounds
+
+#ifdef FN_CreateInstancedBaselines
+void FN_CreateInstancedBaselines(void);
+#endif // FN_CreateInstancedBaselines
+
+#ifdef FN_InconsistentFile
+int FN_InconsistentFile(const edict_t *player, const char *filename, char *disconnect_message);
+#endif // FN_InconsistentFile
+
+#ifdef FN_AllowLagCompensation
+int FN_AllowLagCompensation(void);
+#endif // FN_AllowLagCompensation
+
+
+
+
+#ifdef FN_GameDLLInit_Post
+void FN_GameDLLInit_Post(void);
+#endif // FN_GameDLLInit_Post
+
+#ifdef FN_DispatchSpawn_Post
+int FN_DispatchSpawn_Post(edict_t *pent);
+#endif // FN_DispatchSpawn_Post
+
+#ifdef FN_DispatchThink_Post
+void FN_DispatchThink_Post(edict_t *pent);
+#endif // FN_DispatchThink_Post
+
+#ifdef FN_DispatchUse_Post
+void FN_DispatchUse_Post(edict_t *pentUser, edict_t *pentOther);
+#endif // FN_DispatchUse_Post
+
+#ifdef FN_DispatchTouch_Post
+void FN_DispatchTouch_Post(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_DispatchTouch_Post
+
+#ifdef FN_DispatchBlocked_Post
+void FN_DispatchBlocked_Post(edict_t *pentBlocked, edict_t *pentOther);
+#endif // FN_DispatchBlocked_Post
+
+#ifdef FN_DispatchKeyValue_Post
+void FN_DispatchKeyValue_Post(edict_t *pentKeyvalue, KeyValueData *pkvd);
+#endif // FN_DispatchKeyValue_Post
+
+#ifdef FN_DispatchSave_Post
+void FN_DispatchSave_Post(edict_t *pent, SAVERESTOREDATA *pSaveData);
+#endif // FN_DispatchSave_Post
+
+#ifdef FN_DispatchRestore_Post
+int FN_DispatchRestore_Post(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity);
+#endif // FN_DispatchRestore_Post
+
+#ifdef FN_DispatchObjectCollsionBox_Post
+void FN_DispatchObjectCollsionBox_Post(edict_t *pent);
+#endif // FN_DispatchObjectCollsionBox_Post
+
+#ifdef FN_SaveWriteFields_Post
+void FN_SaveWriteFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveWriteFields_Post
+
+#ifdef FN_SaveReadFields_Post
+void FN_SaveReadFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveReadFields_Post
+
+#ifdef FN_SaveGlobalState_Post
+void FN_SaveGlobalState_Post(SAVERESTOREDATA *pSaveData);
+#endif // FN_SaveGlobalState_Post
+
+#ifdef FN_RestoreGlobalState_Post
+void FN_RestoreGlobalState_Post(SAVERESTOREDATA *pSaveData);
+#endif // FN_RestoreGlobalState_Post
+
+#ifdef FN_ResetGlobalState_Post
+void FN_ResetGlobalState_Post(void);
+#endif // FN_ResetGlobalState_Post
+
+#ifdef FN_ClientConnect_Post
+BOOL FN_ClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]);
+#endif // FN_ClientConnect_Post
+
+#ifdef FN_ClientDisconnect_Post
+void FN_ClientDisconnect_Post(edict_t *pEntity);
+#endif // FN_ClientDisconnect_Post
+
+#ifdef FN_ClientKill_Post
+void FN_ClientKill_Post(edict_t *pEntity);
+#endif // FN_ClientKill_Post
+
+#ifdef FN_ClientPutInServer_Post
+void FN_ClientPutInServer_Post(edict_t *pEntity);
+#endif // FN_ClientPutInServer_Post
+
+#ifdef FN_ClientCommand_Post
+void FN_ClientCommand_Post(edict_t *pEntity);
+#endif // FN_ClientCommand_Post
+
+#ifdef FN_ClientUserInfoChanged_Post
+void FN_ClientUserInfoChanged_Post(edict_t *pEntity, char *infobuffer);
+#endif // FN_ClientUserInfoChanged_Post
+
+#ifdef FN_ServerActivate_Post
+void FN_ServerActivate_Post(edict_t *pEdictList, int edictCount, int clientMax);
+#endif // FN_ServerActivate_Post
+
+#ifdef FN_ServerDeactivate_Post
+void FN_ServerDeactivate_Post(void);
+#endif // FN_ServerDeactivate_Post
+
+#ifdef FN_PlayerPreThink_Post
+void FN_PlayerPreThink_Post(edict_t *pEntity);
+#endif // FN_PlayerPreThink_Post
+
+#ifdef FN_PlayerPostThink_Post
+void FN_PlayerPostThink_Post(edict_t *pEntity);
+#endif // FN_PlayerPostThink_Post
+
+#ifdef FN_StartFrame_Post
+void FN_StartFrame_Post(void);
+#endif // FN_StartFrame_Post
+
+#ifdef FN_ParmsNewLevel_Post
+void FN_ParmsNewLevel_Post(void);
+#endif // FN_ParmsNewLevel_Post
+
+#ifdef FN_ParmsChangeLevel_Post
+void FN_ParmsChangeLevel_Post(void);
+#endif // FN_ParmsChangeLevel_Post
+
+#ifdef FN_GetGameDescription_Post
+const char *FN_GetGameDescription_Post(void);
+#endif // FN_GetGameDescription_Post
+
+#ifdef FN_PlayerCustomization_Post
+void FN_PlayerCustomization_Post(edict_t *pEntity, customization_t *pCust);
+#endif // FN_PlayerCustomization_Post
+
+#ifdef FN_SpectatorConnect_Post
+void FN_SpectatorConnect_Post(edict_t *pEntity);
+#endif // FN_SpectatorConnect_Post
+
+#ifdef FN_SpectatorDisconnect_Post
+void FN_SpectatorDisconnect_Post(edict_t *pEntity);
+#endif // FN_SpectatorDisconnect_Post
+
+#ifdef FN_SpectatorThink_Post
+void FN_SpectatorThink_Post(edict_t *pEntity);
+#endif // FN_SpectatorThink_Post
+
+#ifdef FN_Sys_Error_Post
+void FN_Sys_Error_Post(const char *error_string);
+#endif // FN_Sys_Error_Post
+
+#ifdef FN_PM_Move_Post
+void FN_PM_Move_Post(struct playermove_s *ppmove, int server);
+#endif // FN_PM_Move_Post
+
+#ifdef FN_PM_Init_Post
+void FN_PM_Init_Post(struct playermove_s *ppmove);
+#endif // FN_PM_Init_Post
+
+#ifdef FN_PM_FindTextureType_Post
+char FN_PM_FindTextureType_Post(char *name);
+#endif // FN_PM_FindTextureType_Post
+
+#ifdef FN_SetupVisibility_Post
+void FN_SetupVisibility_Post(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas);
+#endif // FN_SetupVisibility_Post
+
+#ifdef FN_UpdateClientData_Post
+void FN_UpdateClientData_Post(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd);
+#endif // FN_UpdateClientData_Post
+
+#ifdef FN_AddToFullPack_Post
+int FN_AddToFullPack_Post(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet);
+#endif // FN_AddToFullPack_Post
+
+#ifdef FN_CreateBaseline_Post
+void FN_CreateBaseline_Post(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs);
+#endif // FN_CreateBaseline_Post
+
+#ifdef FN_RegisterEncoders_Post
+void FN_RegisterEncoders_Post(void);
+#endif // FN_RegisterEncoders_Post
+
+#ifdef FN_GetWeaponData_Post
+int FN_GetWeaponData_Post(struct edict_s *player, struct weapon_data_s *info);
+#endif // FN_GetWeaponData_Post
+
+#ifdef FN_CmdStart_Post
+void FN_CmdStart_Post(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed);
+#endif // FN_CmdStart_Post
+
+#ifdef FN_CmdEnd_Post
+void FN_CmdEnd_Post(const edict_t *player);
+#endif // FN_CmdEnd_Post
+
+#ifdef FN_ConnectionlessPacket_Post
+int FN_ConnectionlessPacket_Post(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size);
+#endif // FN_ConnectionlessPacket_Post
+
+#ifdef FN_GetHullBounds_Post
+int FN_GetHullBounds_Post(int hullnumber, float *mins, float *maxs);
+#endif // FN_GetHullBounds_Post
+
+#ifdef FN_CreateInstancedBaselines_Post
+void FN_CreateInstancedBaselines_Post(void);
+#endif // FN_CreateInstancedBaselines_Post
+
+#ifdef FN_InconsistentFile_Post
+int FN_InconsistentFile_Post(const edict_t *player, const char *filename, char *disconnect_message);
+#endif // FN_InconsistentFile_Post
+
+#ifdef FN_AllowLagCompensation_Post
+int FN_AllowLagCompensation_Post(void);
+#endif // FN_AllowLagCompensation_Post
+
+
+
+#ifdef FN_PrecacheModel
+int FN_PrecacheModel(char *s);
+#endif // FN_PrecacheModel
+
+#ifdef FN_PrecacheSound
+int FN_PrecacheSound(char *s);
+#endif // FN_PrecacheSound
+
+#ifdef FN_SetModel
+void FN_SetModel(edict_t *e, const char *m);
+#endif // FN_SetModel
+
+#ifdef FN_ModelIndex
+int FN_ModelIndex(const char *m);
+#endif // FN_ModelIndex
+
+#ifdef FN_ModelFrames
+int FN_ModelFrames(int modelIndex);
+#endif // FN_ModelFrames
+
+#ifdef FN_SetSize
+void FN_SetSize(edict_t *e, const float *rgflMin, const float *rgflMax);
+#endif // FN_SetSize
+
+#ifdef FN_ChangeLevel
+void FN_ChangeLevel(char *s1, char *s2);
+#endif // FN_ChangeLevel
+
+#ifdef FN_GetSpawnParms
+void FN_GetSpawnParms(edict_t *ent);
+#endif // FN_GetSpawnParms
+
+#ifdef FN_SaveSpawnParms
+void FN_SaveSpawnParms(edict_t *ent);
+#endif // FN_SaveSpawnParms
+
+#ifdef FN_VecToYaw
+float FN_VecToYaw(const float *rgflVector);
+#endif // FN_VecToYaw
+
+#ifdef FN_VecToAngles
+void FN_VecToAngles(const float *rgflVectorIn, float *rgflVectorOut);
+#endif // FN_VecToAngles
+
+#ifdef FN_MoveToOrigin
+void FN_MoveToOrigin(edict_t *ent, const float *pflGoal, float dist, int iMoveType);
+#endif // FN_MoveToOrigin
+
+#ifdef FN_ChangeYaw
+void FN_ChangeYaw(edict_t *ent);
+#endif // FN_ChangeYaw
+
+#ifdef FN_ChangePitch
+void FN_ChangePitch(edict_t *ent);
+#endif // FN_ChangePitch
+
+#ifdef FN_FindEntityByString
+edict_t *FN_FindEntityByString(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue);
+#endif // FN_FindEntityByString
+
+#ifdef FN_GetEntityIllum
+int FN_GetEntityIllum(edict_t *pEnt);
+#endif // FN_GetEntityIllum
+
+#ifdef FN_FindEntityInSphere
+edict_t *FN_FindEntityInSphere(edict_t *pEdictStartSearchAfter, const float *org, float rad);
+#endif // FN_FindEntityInSphere
+
+#ifdef FN_FindClientInPVS
+edict_t *FN_FindClientInPVS(edict_t *pEdict);
+#endif // FN_FindClientInPVS
+
+#ifdef FN_EntitiesInPVS
+edict_t *FN_EntitiesInPVS(edict_t *pplayer);
+#endif // FN_EntitiesInPVS
+
+#ifdef FN_MakeVectors
+void FN_MakeVectors(const float *rgflVector);
+#endif // FN_MakeVectors
+
+#ifdef FN_AngleVectors
+void FN_AngleVectors(const float *rgflVector, float *forward, float *right, float *up);
+#endif // FN_AngleVectors
+
+#ifdef FN_CreateEntity
+edict_t *FN_CreateEntity(void);
+#endif // FN_CreateEntity
+
+#ifdef FN_RemoveEntity
+void FN_RemoveEntity(edict_t *e);
+#endif // FN_RemoveEntity
+
+#ifdef FN_CreateNamedEntity
+edict_t *FN_CreateNamedEntity(int className);
+#endif // FN_CreateNamedEntity
+
+#ifdef FN_MakeStatic
+void FN_MakeStatic(edict_t *ent);
+#endif // FN_MakeStatic
+
+#ifdef FN_EntIsOnFloor
+int FN_EntIsOnFloor(edict_t *ent);
+#endif // FN_EntIsOnFloor
+
+#ifdef FN_DropToFloor
+int FN_DropToFloor(edict_t *ent);
+#endif // FN_DropToFloor
+
+#ifdef FN_WalkMove
+int FN_WalkMove(edict_t *ent, float yaw, float dist, int iMode);
+#endif // FN_WalkMove
+
+#ifdef FN_SetOrigin
+void FN_SetOrigin(edict_t *e, const float *rgflOrigin);
+#endif // FN_SetOrigin
+
+#ifdef FN_EmitSound
+void FN_EmitSound(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitSound
+
+#ifdef FN_EmitAmbientSound
+void FN_EmitAmbientSound(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitAmbientSound
+
+#ifdef FN_TraceLine
+void FN_TraceLine(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceLine
+
+#ifdef FN_TraceToss
+void FN_TraceToss(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr);
+#endif // FN_TraceToss
+
+#ifdef FN_TraceMonsterHull
+int FN_TraceMonsterHull(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceMonsterHull
+
+#ifdef FN_TraceHull
+void FN_TraceHull(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceHull
+
+#ifdef FN_TraceModel
+void FN_TraceModel(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr);
+#endif // FN_TraceModel
+
+#ifdef FN_TraceTexture
+const char *FN_TraceTexture(edict_t *pTextureEntity, const float *v1, const float *v2 );
+#endif // FN_TraceTexture
+
+#ifdef FN_TraceSphere
+void FN_TraceSphere(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceSphere
+
+#ifdef FN_GetAimVector
+void FN_GetAimVector(edict_t *ent, float speed, float *rgflReturn);
+#endif // FN_GetAimVector
+
+#ifdef FN_ServerCommand
+void FN_ServerCommand(char *str);
+#endif // FN_ServerCommand
+
+#ifdef FN_ServerExecute
+void FN_ServerExecute(void);
+#endif // FN_ServerExecute
+
+#ifdef FN_engClientCommand
+void FN_engClientCommand(edict_t *pEdict, char *szFmt, ...);
+#endif // FN_engClientCommand
+
+#ifdef FN_ParticleEffect
+void FN_ParticleEffect(const float *org, const float *dir, float color, float count);
+#endif // FN_ParticleEffect
+
+#ifdef FN_LightStyle
+void FN_LightStyle(int style, char *val);
+#endif // FN_LightStyle
+
+#ifdef FN_DecalIndex
+int FN_DecalIndex(const char *name);
+#endif // FN_DecalIndex
+
+#ifdef FN_PointContents
+int FN_PointContents(const float *rgflVector);
+#endif // FN_PointContents
+
+#ifdef FN_MessageBegin
+void FN_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_MessageBegin
+
+#ifdef FN_MessageEnd
+void FN_MessageEnd(void);
+#endif // FN_MessageEnd
+
+#ifdef FN_WriteByte
+void FN_WriteByte(int iValue);
+#endif // FN_WriteByte
+
+#ifdef FN_WriteChar
+void FN_WriteChar(int iValue);
+#endif // FN_WriteChar
+
+#ifdef FN_WriteShort
+void FN_WriteShort(int iValue);
+#endif // FN_WriteShort
+
+#ifdef FN_WriteLong
+void FN_WriteLong(int iValue);
+#endif // FN_WriteLong
+
+#ifdef FN_WriteAngle
+void FN_WriteAngle(float flValue);
+#endif // FN_WriteAngle
+
+#ifdef FN_WriteCoord
+void FN_WriteCoord(float flValue);
+#endif // FN_WriteCoord
+
+#ifdef FN_WriteString
+void FN_WriteString(const char *sz);
+#endif // FN_WriteString
+
+#ifdef FN_WriteEntity
+void FN_WriteEntity(int iValue);
+#endif // FN_WriteEntity
+
+#ifdef FN_CVarRegister
+void FN_CVarRegister(cvar_t *pCvar);
+#endif // FN_CVarRegister
+
+#ifdef FN_CVarGetFloat
+float FN_CVarGetFloat(const char *szVarName);
+#endif // FN_CVarGetFloat
+
+#ifdef FN_CVarGetString
+const char *FN_CVarGetString(const char *szVarName);
+#endif // FN_CVarGetString
+
+#ifdef FN_CVarSetFloat
+void FN_CVarSetFloat(const char *szVarName, float flValue);
+#endif // FN_CVarSetFloat
+
+#ifdef FN_CVarSetString
+void FN_CVarSetString(const char *szVarName, const char *szValue);
+#endif // FN_CVarSetString
+
+#ifdef FN_AlertMessage
+void FN_AlertMessage(ALERT_TYPE atype, char *szFmt, ...);
+#endif // FN_AlertMessage
+
+#ifdef FN_EngineFprintf
+void FN_EngineFprintf(FILE *pfile, char *szFmt, ...);
+#endif // FN_EngineFprintf
+
+#ifdef FN_PvAllocEntPrivateData
+void *FN_PvAllocEntPrivateData(edict_t *pEdict, int32 cb);
+#endif // FN_PvAllocEntPrivateData
+
+#ifdef FN_PvEntPrivateData
+void *FN_PvEntPrivateData(edict_t *pEdict);
+#endif // FN_PvEntPrivateData
+
+#ifdef FN_FreeEntPrivateData
+void FN_FreeEntPrivateData(edict_t *pEdict);
+#endif // FN_FreeEntPrivateData
+
+#ifdef FN_SzFromIndex
+const char *FN_SzFromIndex(int iString);
+#endif // FN_SzFromIndex
+
+#ifdef FN_AllocString
+int FN_AllocString(const char *szValue);
+#endif // FN_AllocString
+
+#ifdef FN_GetVarsOfEnt
+struct entvars_s *FN_GetVarsOfEnt(edict_t *pEdict);
+#endif // FN_GetVarsOfEnt
+
+#ifdef FN_PEntityOfEntOffset
+edict_t *FN_PEntityOfEntOffset(int iEntOffset);
+#endif // FN_PEntityOfEntOffset
+
+#ifdef FN_EntOffsetOfPEntity
+int FN_EntOffsetOfPEntity(const edict_t *pEdict);
+#endif // FN_EntOffsetOfPEntity
+
+#ifdef FN_IndexOfEdict
+int FN_IndexOfEdict(const edict_t *pEdict);
+#endif // FN_IndexOfEdict
+
+#ifdef FN_PEntityOfEntIndex
+edict_t *FN_PEntityOfEntIndex(int iEntIndex);
+#endif // FN_PEntityOfEntIndex
+
+#ifdef FN_FindEntityByVars
+edict_t *FN_FindEntityByVars(struct entvars_s *pvars);
+#endif // FN_FindEntityByVars
+
+#ifdef FN_GetModelPtr
+void *FN_GetModelPtr(edict_t *pEdict);
+#endif // FN_GetModelPtr
+
+#ifdef FN_RegUserMsg
+int FN_RegUserMsg(const char *pszName, int iSize);
+#endif // FN_RegUserMsg
+
+#ifdef FN_AnimationAutomove
+void FN_AnimationAutomove(const edict_t *pEdict, float flTime);
+#endif // FN_AnimationAutomove
+
+#ifdef FN_GetBonePosition
+void FN_GetBonePosition(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles);
+#endif // FN_GetBonePosition
+
+#ifdef FN_FunctionFromName
+unsigned long FN_FunctionFromName(const char *pName);
+#endif // FN_FunctionFromName
+
+#ifdef FN_NameForFunction
+const char *FN_NameForFunction(unsigned long function);
+#endif // FN_NameForFunction
+
+#ifdef FN_ClientPrintf
+void FN_ClientPrintf(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg);
+#endif // FN_ClientPrintf
+
+#ifdef FN_ServerPrint
+void FN_ServerPrint(const char *szMsg);
+#endif // FN_ServerPrint
+
+#ifdef FN_Cmd_Args
+const char *FN_Cmd_Args(void);
+#endif // FN_Cmd_Args
+
+#ifdef FN_Cmd_Argv
+const char *FN_Cmd_Argv(int argc);
+#endif // FN_Cmd_Argv
+
+#ifdef FN_Cmd_Argc
+int FN_Cmd_Argc(void);
+#endif // FN_Cmd_Argc
+
+#ifdef FN_GetAttachment
+void FN_GetAttachment(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles );
+#endif // FN_GetAttachment
+
+#ifdef FN_CRC32_Init
+void FN_CRC32_Init(CRC32_t *pulCRC);
+#endif // FN_CRC32_Init
+
+#ifdef FN_CRC32_ProcessBuffer
+void FN_CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len);
+#endif // FN_CRC32_ProcessBuffer
+
+#ifdef FN_CRC32_ProcessByte
+void FN_CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch);
+#endif // FN_CRC32_ProcessByte
+
+#ifdef FN_CRC32_Final
+CRC32_t FN_CRC32_Final(CRC32_t pulCRC);
+#endif // FN_CRC32_Final
+
+#ifdef FN_RandomLong
+long FN_RandomLong(long lLow, long lHigh);
+#endif // FN_RandomLong
+
+#ifdef FN_RandomFloat
+float FN_RandomFloat(float flLow, float flHigh);
+#endif // FN_RandomFloat
+
+#ifdef FN_SetView
+void FN_SetView(const edict_t *pClient, const edict_t *pViewent);
+#endif // FN_SetView
+
+#ifdef FN_Time
+float FN_Time(void);
+#endif // FN_Time
+
+#ifdef FN_CrosshairAngle
+void FN_CrosshairAngle(const edict_t *pClient, float pitch, float yaw);
+#endif // FN_CrosshairAngle
+
+#ifdef FN_LoadFileForMe
+byte *FN_LoadFileForMe(char *filename, int *pLength);
+#endif // FN_LoadFileForMe
+
+#ifdef FN_FreeFile
+void FN_FreeFile(void *buffer);
+#endif // FN_FreeFile
+
+#ifdef FN_EndSection
+void FN_EndSection(const char *pszSectionName);
+#endif // FN_EndSection
+
+#ifdef FN_CompareFileTime
+int FN_CompareFileTime(char *filename1, char *filename2, int *iCompare);
+#endif // FN_CompareFileTime
+
+#ifdef FN_GetGameDir
+void FN_GetGameDir(char *szGetGameDir);
+#endif // FN_GetGameDir
+
+#ifdef FN_Cvar_RegisterVariable
+void FN_Cvar_RegisterVariable(cvar_t *variable);
+#endif // FN_Cvar_RegisterVariable
+
+#ifdef FN_FadeClientVolume
+void FN_FadeClientVolume(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds);
+#endif // FN_FadeClientVolume
+
+#ifdef FN_SetClientMaxspeed
+void FN_SetClientMaxspeed(const edict_t *pEdict, float fNewMaxspeed);
+#endif // FN_SetClientMaxspeed
+
+#ifdef FN_CreateFakeClient
+edict_t *FN_CreateFakeClient(const char *netname);
+#endif // FN_CreateFakeClient
+
+#ifdef FN_RunPlayerMove
+void FN_RunPlayerMove(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec);
+#endif // FN_RunPlayerMove
+
+#ifdef FN_NumberOfEntities
+int FN_NumberOfEntities(void);
+#endif // FN_NumberOfEntities
+
+#ifdef FN_GetInfoKeyBuffer
+char *FN_GetInfoKeyBuffer(edict_t *e);
+#endif // FN_GetInfoKeyBuffer
+
+#ifdef FN_InfoKeyValue
+char *FN_InfoKeyValue(char *infobuffer, char *key);
+#endif // FN_InfoKeyValue
+
+#ifdef FN_SetKeyValue
+void FN_SetKeyValue(char *infobuffer, char *key, char *value);
+#endif // FN_SetKeyValue
+
+#ifdef FN_SetClientKeyValue
+void FN_SetClientKeyValue(int clientIndex, char *infobuffer, char *key, char *value);
+#endif // FN_SetClientKeyValue
+
+#ifdef FN_IsMapValid
+int FN_IsMapValid(char *filename);
+#endif // FN_IsMapValid
+
+#ifdef FN_StaticDecal
+void FN_StaticDecal(const float *origin, int decalIndex, int entityIndex, int modelIndex);
+#endif // FN_StaticDecal
+
+#ifdef FN_PrecacheGeneric
+int FN_PrecacheGeneric(char *s);
+#endif // FN_PrecacheGeneric
+
+#ifdef FN_GetPlayerUserId
+int FN_GetPlayerUserId(edict_t *e );
+#endif // FN_GetPlayerUserId
+
+#ifdef FN_BuildSoundMsg
+void FN_BuildSoundMsg(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_BuildSoundMsg
+
+#ifdef FN_IsDedicatedServer
+int FN_IsDedicatedServer(void);
+#endif // FN_IsDedicatedServer
+
+#ifdef FN_CVarGetPointer
+cvar_t *FN_CVarGetPointer(const char *szVarName);
+#endif // FN_CVarGetPointer
+
+#ifdef FN_GetPlayerWONId
+unsigned int FN_GetPlayerWONId(edict_t *e);
+#endif // FN_GetPlayerWONId
+
+#ifdef FN_Info_RemoveKey
+void FN_Info_RemoveKey( char *s, const char *key);
+#endif // FN_Info_RemoveKey
+
+#ifdef FN_GetPhysicsKeyValue
+const char *FN_GetPhysicsKeyValue(const edict_t *pClient, const char *key);
+#endif // FN_GetPhysicsKeyValue
+
+#ifdef FN_SetPhysicsKeyValue
+void FN_SetPhysicsKeyValue(const edict_t *pClient, const char *key, const char *value);
+#endif // FN_SetPhysicsKeyValue
+
+#ifdef FN_GetPhysicsInfoString
+const char *FN_GetPhysicsInfoString( const edict_t *pClient);
+#endif // FN_GetPhysicsInfoString
+
+#ifdef FN_PrecacheEvent
+unsigned short FN_PrecacheEvent(int type, const char *psz);
+#endif // FN_PrecacheEvent
+
+#ifdef FN_PlaybackEvent
+void FN_PlaybackEvent(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2);
+#endif // FN_PlaybackEvent
+
+#ifdef FN_SetFatPVS
+unsigned char *FN_SetFatPVS(float *org);
+#endif // FN_SetFatPVS
+
+#ifdef FN_SetFatPAS
+unsigned char *FN_SetFatPAS(float *org);
+#endif // FN_SetFatPAS
+
+#ifdef FN_CheckVisibility
+int FN_CheckVisibility(const edict_t *entity, unsigned char *pset);
+#endif // FN_CheckVisibility
+
+#ifdef FN_DeltaSetField
+void FN_DeltaSetField(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaSetField
+
+#ifdef FN_DeltaUnsetField
+void FN_DeltaUnsetField(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaUnsetField
+
+#ifdef FN_DeltaAddEncoder
+void FN_DeltaAddEncoder(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) );
+#endif // FN_DeltaAddEncoder
+
+#ifdef FN_GetCurrentPlayer
+int FN_GetCurrentPlayer(void);
+#endif // FN_GetCurrentPlayer
+
+#ifdef FN_CanSkipPlayer
+int FN_CanSkipPlayer(const edict_t *player);
+#endif // FN_CanSkipPlayer
+
+#ifdef FN_DeltaFindField
+int FN_DeltaFindField(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaFindField
+
+#ifdef FN_DeltaSetFieldByIndex
+void FN_DeltaSetFieldByIndex(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaSetFieldByIndex
+
+#ifdef FN_DeltaUnsetFieldByIndex
+void FN_DeltaUnsetFieldByIndex(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaUnsetFieldByIndex
+
+#ifdef FN_SetGroupMask
+void FN_SetGroupMask(int mask, int op);
+#endif // FN_SetGroupMask
+
+#ifdef FN_engCreateInstancedBaseline
+int FN_engCreateInstancedBaseline(int classname, struct entity_state_s *baseline);
+#endif // FN_engCreateInstancedBaseline
+
+#ifdef FN_Cvar_DirectSet
+void FN_Cvar_DirectSet(struct cvar_s *var, char *value);
+#endif // FN_Cvar_DirectSet
+
+#ifdef FN_ForceUnmodified
+void FN_ForceUnmodified(FORCE_TYPE type, float *mins, float *maxs, const char *filename);
+#endif // FN_ForceUnmodified
+
+#ifdef FN_GetPlayerStats
+void FN_GetPlayerStats(const edict_t *pClient, int *ping, int *packet_loss);
+#endif // FN_GetPlayerStats
+
+#ifdef FN_AddServerCommand
+void FN_AddServerCommand(char *cmd_name, void (*function) (void));
+#endif // FN_AddServerCommand
+
+#ifdef FN_Voice_GetClientListening
+qboolean FN_Voice_GetClientListening(int iReceiver, int iSender);
+#endif // FN_Voice_GetClientListening
+
+#ifdef FN_Voice_SetClientListening
+qboolean FN_Voice_SetClientListening(int iReceiver, int iSender, qboolean bListen);
+#endif // FN_Voice_SetClientListening
+
+#ifdef FN_GetPlayerAuthId
+const char *FN_GetPlayerAuthId(edict_t *e);
+#endif // FN_GetPlayerAuthId
+
+
+
+
+
+
+#ifdef FN_PrecacheModel_Post
+int FN_PrecacheModel_Post(char *s);
+#endif // FN_PrecacheModel_Post
+
+#ifdef FN_PrecacheSound_Post
+int FN_PrecacheSound_Post(char *s);
+#endif // FN_PrecacheSound_Post
+
+#ifdef FN_SetModel_Post
+void FN_SetModel_Post(edict_t *e, const char *m);
+#endif // FN_SetModel_Post
+
+#ifdef FN_ModelIndex_Post
+int FN_ModelIndex_Post(const char *m);
+#endif // FN_ModelIndex_Post
+
+#ifdef FN_ModelFrames_Post
+int FN_ModelFrames_Post(int modelIndex);
+#endif // FN_ModelFrames_Post
+
+#ifdef FN_SetSize_Post
+void FN_SetSize_Post(edict_t *e, const float *rgflMin, const float *rgflMax);
+#endif // FN_SetSize_Post
+
+#ifdef FN_ChangeLevel_Post
+void FN_ChangeLevel_Post(char *s1, char *s2);
+#endif // FN_ChangeLevel_Post
+
+#ifdef FN_GetSpawnParms_Post
+void FN_GetSpawnParms_Post(edict_t *ent);
+#endif // FN_GetSpawnParms_Post
+
+#ifdef FN_SaveSpawnParms_Post
+void FN_SaveSpawnParms_Post(edict_t *ent);
+#endif // FN_SaveSpawnParms_Post
+
+#ifdef FN_VecToYaw_Post
+float FN_VecToYaw_Post(const float *rgflVector);
+#endif // FN_VecToYaw_Post
+
+#ifdef FN_VecToAngles_Post
+void FN_VecToAngles_Post(const float *rgflVectorIn, float *rgflVectorOut);
+#endif // FN_VecToAngles_Post
+
+#ifdef FN_MoveToOrigin_Post
+void FN_MoveToOrigin_Post(edict_t *ent, const float *pflGoal, float dist, int iMoveType);
+#endif // FN_MoveToOrigin_Post
+
+#ifdef FN_ChangeYaw_Post
+void FN_ChangeYaw_Post(edict_t *ent);
+#endif // FN_ChangeYaw_Post
+
+#ifdef FN_ChangePitch_Post
+void FN_ChangePitch_Post(edict_t *ent);
+#endif // FN_ChangePitch_Post
+
+#ifdef FN_FindEntityByString_Post
+edict_t *FN_FindEntityByString_Post(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue);
+#endif // FN_FindEntityByString_Post
+
+#ifdef FN_GetEntityIllum_Post
+int FN_GetEntityIllum_Post(edict_t *pEnt);
+#endif // FN_GetEntityIllum_Post
+
+#ifdef FN_FindEntityInSphere_Post
+edict_t *FN_FindEntityInSphere_Post(edict_t *pEdictStartSearchAfter, const float *org, float rad);
+#endif // FN_FindEntityInSphere_Post
+
+#ifdef FN_FindClientInPVS_Post
+edict_t *FN_FindClientInPVS_Post(edict_t *pEdict);
+#endif // FN_FindClientInPVS_Post
+
+#ifdef FN_EntitiesInPVS_Post
+edict_t *FN_EntitiesInPVS_Post(edict_t *pplayer);
+#endif // FN_EntitiesInPVS_Post
+
+#ifdef FN_MakeVectors_Post
+void FN_MakeVectors_Post(const float *rgflVector);
+#endif // FN_MakeVectors_Post
+
+#ifdef FN_AngleVectors_Post
+void FN_AngleVectors_Post(const float *rgflVector, float *forward, float *right, float *up);
+#endif // FN_AngleVectors_Post
+
+#ifdef FN_CreateEntity_Post
+edict_t *FN_CreateEntity_Post(void);
+#endif // FN_CreateEntity_Post
+
+#ifdef FN_RemoveEntity_Post
+void FN_RemoveEntity_Post(edict_t *e);
+#endif // FN_RemoveEntity_Post
+
+#ifdef FN_CreateNamedEntity_Post
+edict_t *FN_CreateNamedEntity_Post(int className);
+#endif // FN_CreateNamedEntity_Post
+
+#ifdef FN_MakeStatic_Post
+void FN_MakeStatic_Post(edict_t *ent);
+#endif // FN_MakeStatic_Post
+
+#ifdef FN_EntIsOnFloor_Post
+int FN_EntIsOnFloor_Post(edict_t *ent);
+#endif // FN_EntIsOnFloor_Post
+
+#ifdef FN_DropToFloor_Post
+int FN_DropToFloor_Post(edict_t *ent);
+#endif // FN_DropToFloor_Post
+
+#ifdef FN_WalkMove_Post
+int FN_WalkMove_Post(edict_t *ent, float yaw, float dist, int iMode);
+#endif // FN_WalkMove_Post
+
+#ifdef FN_SetOrigin_Post
+void FN_SetOrigin_Post(edict_t *e, const float *rgflOrigin);
+#endif // FN_SetOrigin_Post
+
+#ifdef FN_EmitSound_Post
+void FN_EmitSound_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitSound_Post
+
+#ifdef FN_EmitAmbientSound_Post
+void FN_EmitAmbientSound_Post(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitAmbientSound_Post
+
+#ifdef FN_TraceLine_Post
+void FN_TraceLine_Post(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceLine_Post
+
+#ifdef FN_TraceToss_Post
+void FN_TraceToss_Post(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr);
+#endif // FN_TraceToss_Post
+
+#ifdef FN_TraceMonsterHull_Post
+int FN_TraceMonsterHull_Post(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceMonsterHull_Post
+
+#ifdef FN_TraceHull_Post
+void FN_TraceHull_Post(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceHull_Post
+
+#ifdef FN_TraceModel_Post
+void FN_TraceModel_Post(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr);
+#endif // FN_TraceModel_Post
+
+#ifdef FN_TraceTexture_Post
+const char *FN_TraceTexture_Post(edict_t *pTextureEntity, const float *v1, const float *v2 );
+#endif // FN_TraceTexture_Post
+
+#ifdef FN_TraceSphere_Post
+void FN_TraceSphere_Post(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceSphere_Post
+
+#ifdef FN_GetAimVector_Post
+void FN_GetAimVector_Post(edict_t *ent, float speed, float *rgflReturn);
+#endif // FN_GetAimVector_Post
+
+#ifdef FN_ServerCommand_Post
+void FN_ServerCommand_Post(char *str);
+#endif // FN_ServerCommand_Post
+
+#ifdef FN_ServerExecute_Post
+void FN_ServerExecute_Post(void);
+#endif // FN_ServerExecute_Post
+
+#ifdef FN_engClientCommand_Post
+void FN_engClientCommand_Post(edict_t *pEdict, char *szFmt, ...);
+#endif // FN_engClientCommand_Post
+
+#ifdef FN_ParticleEffect_Post
+void FN_ParticleEffect_Post(const float *org, const float *dir, float color, float count);
+#endif // FN_ParticleEffect_Post
+
+#ifdef FN_LightStyle_Post
+void FN_LightStyle_Post(int style, char *val);
+#endif // FN_LightStyle_Post
+
+#ifdef FN_DecalIndex_Post
+int FN_DecalIndex_Post(const char *name);
+#endif // FN_DecalIndex_Post
+
+#ifdef FN_PointContents_Post
+int FN_PointContents_Post(const float *rgflVector);
+#endif // FN_PointContents_Post
+
+#ifdef FN_MessageBegin_Post
+void FN_MessageBegin_Post(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_MessageBegin_Post
+
+#ifdef FN_MessageEnd_Post
+void FN_MessageEnd_Post(void);
+#endif // FN_MessageEnd_Post
+
+#ifdef FN_WriteByte_Post
+void FN_WriteByte_Post(int iValue);
+#endif // FN_WriteByte_Post
+
+#ifdef FN_WriteChar_Post
+void FN_WriteChar_Post(int iValue);
+#endif // FN_WriteChar_Post
+
+#ifdef FN_WriteShort_Post
+void FN_WriteShort_Post(int iValue);
+#endif // FN_WriteShort_Post
+
+#ifdef FN_WriteLong_Post
+void FN_WriteLong_Post(int iValue);
+#endif // FN_WriteLong_Post
+
+#ifdef FN_WriteAngle_Post
+void FN_WriteAngle_Post(float flValue);
+#endif // FN_WriteAngle_Post
+
+#ifdef FN_WriteCoord_Post
+void FN_WriteCoord_Post(float flValue);
+#endif // FN_WriteCoord_Post
+
+#ifdef FN_WriteString_Post
+void FN_WriteString_Post(const char *sz);
+#endif // FN_WriteString_Post
+
+#ifdef FN_WriteEntity_Post
+void FN_WriteEntity_Post(int iValue);
+#endif // FN_WriteEntity_Post
+
+#ifdef FN_CVarRegister_Post
+void FN_CVarRegister_Post(cvar_t *pCvar);
+#endif // FN_CVarRegister_Post
+
+#ifdef FN_CVarGetFloat_Post
+float FN_CVarGetFloat_Post(const char *szVarName);
+#endif // FN_CVarGetFloat_Post
+
+#ifdef FN_CVarGetString_Post
+const char *FN_CVarGetString_Post(const char *szVarName);
+#endif // FN_CVarGetString_Post
+
+#ifdef FN_CVarSetFloat_Post
+void FN_CVarSetFloat_Post(const char *szVarName, float flValue);
+#endif // FN_CVarSetFloat_Post
+
+#ifdef FN_CVarSetString_Post
+void FN_CVarSetString_Post(const char *szVarName, const char *szValue);
+#endif // FN_CVarSetString_Post
+
+#ifdef FN_AlertMessage_Post
+void FN_AlertMessage_Post(ALERT_TYPE atype, char *szFmt, ...);
+#endif // FN_AlertMessage_Post
+
+#ifdef FN_EngineFprintf_Post
+void FN_EngineFprintf_Post(FILE *pfile, char *szFmt, ...);
+#endif // FN_EngineFprintf_Post
+
+#ifdef FN_PvAllocEntPrivateData_Post
+void *FN_PvAllocEntPrivateData_Post(edict_t *pEdict, long cb);
+#endif // FN_PvAllocEntPrivateData_Post
+
+#ifdef FN_PvEntPrivateData_Post
+void *FN_PvEntPrivateData_Post(edict_t *pEdict);
+#endif // FN_PvEntPrivateData_Post
+
+#ifdef FN_FreeEntPrivateData_Post
+void FN_FreeEntPrivateData_Post(edict_t *pEdict);
+#endif // FN_FreeEntPrivateData_Post
+
+#ifdef FN_SzFromIndex_Post
+const char *FN_SzFromIndex_Post(int iString);
+#endif // FN_SzFromIndex_Post
+
+#ifdef FN_AllocString_Post
+int FN_AllocString_Post(const char *szValue);
+#endif // FN_AllocString_Post
+
+#ifdef FN_GetVarsOfEnt_Post
+struct entvars_s *FN_GetVarsOfEnt_Post(edict_t *pEdict);
+#endif // FN_GetVarsOfEnt_Post
+
+#ifdef FN_PEntityOfEntOffset_Post
+edict_t *FN_PEntityOfEntOffset_Post(int iEntOffset);
+#endif // FN_PEntityOfEntOffset_Post
+
+#ifdef FN_EntOffsetOfPEntity_Post
+int FN_EntOffsetOfPEntity_Post(const edict_t *pEdict);
+#endif // FN_EntOffsetOfPEntity_Post
+
+#ifdef FN_IndexOfEdict_Post
+int FN_IndexOfEdict_Post(const edict_t *pEdict);
+#endif // FN_IndexOfEdict_Post
+
+#ifdef FN_PEntityOfEntIndex_Post
+edict_t *FN_PEntityOfEntIndex_Post(int iEntIndex);
+#endif // FN_PEntityOfEntIndex_Post
+
+#ifdef FN_FindEntityByVars_Post
+edict_t *FN_FindEntityByVars_Post(struct entvars_s *pvars);
+#endif // FN_FindEntityByVars_Post
+
+#ifdef FN_GetModelPtr_Post
+void *FN_GetModelPtr_Post(edict_t *pEdict);
+#endif // FN_GetModelPtr_Post
+
+#ifdef FN_RegUserMsg_Post
+int FN_RegUserMsg_Post(const char *pszName, int iSize);
+#endif // FN_RegUserMsg_Post
+
+#ifdef FN_AnimationAutomove_Post
+void FN_AnimationAutomove_Post(const edict_t *pEdict, float flTime);
+#endif // FN_AnimationAutomove_Post
+
+#ifdef FN_GetBonePosition_Post
+void FN_GetBonePosition_Post(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles);
+#endif // FN_GetBonePosition_Post
+
+#ifdef FN_FunctionFromName_Post
+unsigned long FN_FunctionFromName_Post(const char *pName);
+#endif // FN_FunctionFromName_Post
+
+#ifdef FN_NameForFunction_Post
+const char *FN_NameForFunction_Post(unsigned long function);
+#endif // FN_NameForFunction_Post
+
+#ifdef FN_ClientPrintf_Post
+void FN_ClientPrintf_Post(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg);
+#endif // FN_ClientPrintf_Post
+
+#ifdef FN_ServerPrint_Post
+void FN_ServerPrint_Post(const char *szMsg);
+#endif // FN_ServerPrint_Post
+
+#ifdef FN_Cmd_Args_Post
+const char *FN_Cmd_Args_Post(void);
+#endif // FN_Cmd_Args_Post
+
+#ifdef FN_Cmd_Argv_Post
+const char *FN_Cmd_Argv_Post(int argc);
+#endif // FN_Cmd_Argv_Post
+
+#ifdef FN_Cmd_Argc_Post
+int FN_Cmd_Argc_Post(void);
+#endif // FN_Cmd_Argc_Post
+
+#ifdef FN_GetAttachment_Post
+void FN_GetAttachment_Post(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles );
+#endif // FN_GetAttachment_Post
+
+#ifdef FN_CRC32_Init_Post
+void FN_CRC32_Init_Post(CRC32_t *pulCRC);
+#endif // FN_CRC32_Init_Post
+
+#ifdef FN_CRC32_ProcessBuffer_Post
+void FN_CRC32_ProcessBuffer_Post(CRC32_t *pulCRC, void *p, int len);
+#endif // FN_CRC32_ProcessBuffer_Post
+
+#ifdef FN_CRC32_ProcessByte_Post
+void FN_CRC32_ProcessByte_Post(CRC32_t *pulCRC, unsigned char ch);
+#endif // FN_CRC32_ProcessByte_Post
+
+#ifdef FN_CRC32_Final_Post
+CRC32_t FN_CRC32_Final_Post(CRC32_t pulCRC);
+#endif // FN_CRC32_Final_Post
+
+#ifdef FN_RandomLong_Post
+long FN_RandomLong_Post(long lLow, long lHigh);
+#endif // FN_RandomLong_Post
+
+#ifdef FN_RandomFloat_Post
+float FN_RandomFloat_Post(float flLow, float flHigh);
+#endif // FN_RandomFloat_Post
+
+#ifdef FN_SetView_Post
+void FN_SetView_Post(const edict_t *pClient, const edict_t *pViewent);
+#endif // FN_SetView_Post
+
+#ifdef FN_Time_Post
+float FN_Time_Post(void);
+#endif // FN_Time_Post
+
+#ifdef FN_CrosshairAngle_Post
+void FN_CrosshairAngle_Post(const edict_t *pClient, float pitch, float yaw);
+#endif // FN_CrosshairAngle_Post
+
+#ifdef FN_LoadFileForMe_Post
+byte *FN_LoadFileForMe_Post(char *filename, int *pLength);
+#endif // FN_LoadFileForMe_Post
+
+#ifdef FN_FreeFile_Post
+void FN_FreeFile_Post(void *buffer);
+#endif // FN_FreeFile_Post
+
+#ifdef FN_EndSection_Post
+void FN_EndSection_Post(const char *pszSectionName);
+#endif // FN_EndSection_Post
+
+#ifdef FN_CompareFileTime_Post
+int FN_CompareFileTime_Post(char *filename1, char *filename2, int *iCompare);
+#endif // FN_CompareFileTime_Post
+
+#ifdef FN_GetGameDir_Post
+void FN_GetGameDir_Post(char *szGetGameDir);
+#endif // FN_GetGameDir_Post
+
+#ifdef FN_Cvar_RegisterVariable_Post
+void FN_Cvar_RegisterVariable_Post(cvar_t *variable);
+#endif // FN_Cvar_RegisterVariable_Post
+
+#ifdef FN_FadeClientVolume_Post
+void FN_FadeClientVolume_Post(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds);
+#endif // FN_FadeClientVolume_Post
+
+#ifdef FN_SetClientMaxspeed_Post
+void FN_SetClientMaxspeed_Post(const edict_t *pEdict, float fNewMaxspeed);
+#endif // FN_SetClientMaxspeed_Post
+
+#ifdef FN_CreateFakeClient_Post
+edict_t *FN_CreateFakeClient_Post(const char *netname);
+#endif // FN_CreateFakeClient_Post
+
+#ifdef FN_RunPlayerMove_Post
+void FN_RunPlayerMove_Post(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec);
+#endif // FN_RunPlayerMove_Post
+
+#ifdef FN_NumberOfEntities_Post
+int FN_NumberOfEntities_Post(void);
+#endif // FN_NumberOfEntities_Post
+
+#ifdef FN_GetInfoKeyBuffer_Post
+char *FN_GetInfoKeyBuffer_Post(edict_t *e);
+#endif // FN_GetInfoKeyBuffer_Post
+
+#ifdef FN_InfoKeyValue_Post
+char *FN_InfoKeyValue_Post(char *infobuffer, char *key);
+#endif // FN_InfoKeyValue_Post
+
+#ifdef FN_SetKeyValue_Post
+void FN_SetKeyValue_Post(char *infobuffer, char *key, char *value);
+#endif // FN_SetKeyValue_Post
+
+#ifdef FN_SetClientKeyValue_Post
+void FN_SetClientKeyValue_Post(int clientIndex, char *infobuffer, char *key, char *value);
+#endif // FN_SetClientKeyValue_Post
+
+#ifdef FN_IsMapValid_Post
+int FN_IsMapValid_Post(char *filename);
+#endif // FN_IsMapValid_Post
+
+#ifdef FN_StaticDecal_Post
+void FN_StaticDecal_Post(const float *origin, int decalIndex, int entityIndex, int modelIndex);
+#endif // FN_StaticDecal_Post
+
+#ifdef FN_PrecacheGeneric_Post
+int FN_PrecacheGeneric_Post(char *s);
+#endif // FN_PrecacheGeneric_Post
+
+#ifdef FN_GetPlayerUserId_Post
+int FN_GetPlayerUserId_Post(edict_t *e );
+#endif // FN_GetPlayerUserId_Post
+
+#ifdef FN_BuildSoundMsg_Post
+void FN_BuildSoundMsg_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_BuildSoundMsg_Post
+
+#ifdef FN_IsDedicatedServer_Post
+int FN_IsDedicatedServer_Post(void);
+#endif // FN_IsDedicatedServer_Post
+
+#ifdef FN_CVarGetPointer_Post
+cvar_t *FN_CVarGetPointer_Post(const char *szVarName);
+#endif // FN_CVarGetPointer_Post
+
+#ifdef FN_GetPlayerWONId_Post
+unsigned int FN_GetPlayerWONId_Post(edict_t *e);
+#endif // FN_GetPlayerWONId_Post
+
+#ifdef FN_Info_RemoveKey_Post
+void FN_Info_RemoveKey_Post( char *s, const char *key);
+#endif // FN_Info_RemoveKey_Post
+
+#ifdef FN_GetPhysicsKeyValue_Post
+const char *FN_GetPhysicsKeyValue_Post(const edict_t *pClient, const char *key);
+#endif // FN_GetPhysicsKeyValue_Post
+
+#ifdef FN_SetPhysicsKeyValue_Post
+void FN_SetPhysicsKeyValue_Post(const edict_t *pClient, const char *key, const char *value);
+#endif // FN_SetPhysicsKeyValue_Post
+
+#ifdef FN_GetPhysicsInfoString_Post
+const char *FN_GetPhysicsInfoString_Post( const edict_t *pClient);
+#endif // FN_GetPhysicsInfoString_Post
+
+#ifdef FN_PrecacheEvent_Post
+unsigned short FN_PrecacheEvent_Post(int type, const char *psz);
+#endif // FN_PrecacheEvent_Post
+
+#ifdef FN_PlaybackEvent_Post
+void FN_PlaybackEvent_Post(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2);
+#endif // FN_PlaybackEvent_Post
+
+#ifdef FN_SetFatPVS_Post
+unsigned char *FN_SetFatPVS_Post(float *org);
+#endif // FN_SetFatPVS_Post
+
+#ifdef FN_SetFatPAS_Post
+unsigned char *FN_SetFatPAS_Post(float *org);
+#endif // FN_SetFatPAS_Post
+
+#ifdef FN_CheckVisibility_Post
+int FN_CheckVisibility_Post(const edict_t *entity, unsigned char *pset);
+#endif // FN_CheckVisibility_Post
+
+#ifdef FN_DeltaSetField_Post
+void FN_DeltaSetField_Post(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaSetField_Post
+
+#ifdef FN_DeltaUnsetField_Post
+void FN_DeltaUnsetField_Post(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaUnsetField_Post
+
+#ifdef FN_DeltaAddEncoder_Post
+void FN_DeltaAddEncoder_Post(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) );
+#endif // FN_DeltaAddEncoder_Post
+
+#ifdef FN_GetCurrentPlayer_Post
+int FN_GetCurrentPlayer_Post(void);
+#endif // FN_GetCurrentPlayer_Post
+
+#ifdef FN_CanSkipPlayer_Post
+int FN_CanSkipPlayer_Post(const edict_t *player);
+#endif // FN_CanSkipPlayer_Post
+
+#ifdef FN_DeltaFindField_Post
+int FN_DeltaFindField_Post(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaFindField_Post
+
+#ifdef FN_DeltaSetFieldByIndex_Post
+void FN_DeltaSetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaSetFieldByIndex_Post
+
+#ifdef FN_DeltaUnsetFieldByIndex_Post
+void FN_DeltaUnsetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaUnsetFieldByIndex_Post
+
+#ifdef FN_SetGroupMask_Post
+void FN_SetGroupMask_Post(int mask, int op);
+#endif // FN_SetGroupMask_Post
+
+#ifdef FN_engCreateInstancedBaseline_Post
+int FN_engCreateInstancedBaseline_Post(int classname, struct entity_state_s *baseline);
+#endif // FN_engCreateInstancedBaseline_Post
+
+#ifdef FN_Cvar_DirectSet_Post
+void FN_Cvar_DirectSet_Post(struct cvar_s *var, char *value);
+#endif // FN_Cvar_DirectSet_Post
+
+#ifdef FN_ForceUnmodified_Post
+void FN_ForceUnmodified_Post(FORCE_TYPE type, float *mins, float *maxs, const char *filename);
+#endif // FN_ForceUnmodified_Post
+
+#ifdef FN_GetPlayerStats_Post
+void FN_GetPlayerStats_Post(const edict_t *pClient, int *ping, int *packet_loss);
+#endif // FN_GetPlayerStats_Post
+
+#ifdef FN_AddServerCommand_Post
+void FN_AddServerCommand_Post(char *cmd_name, void (*function)(void));
+#endif // FN_AddServerCommand_Post
+
+#ifdef FN_Voice_GetClientListening_Post
+qboolean FN_Voice_GetClientListening_Post(int iReceiver, int iSender);
+#endif // FN_Voice_GetClientListening_Post
+
+#ifdef FN_Voice_SetClientListening_Post
+qboolean FN_Voice_SetClientListening_Post(int iReceiver, int iSender, qboolean bListen);
+#endif // FN_Voice_SetClientListening_Post
+
+#ifdef FN_GetPlayerAuthId_Post
+const char *FN_GetPlayerAuthId_Post(edict_t *e);
+#endif // FN_GetPlayerAuthId
+
+
+
+
+#ifdef FN_OnFreeEntPrivateData
+void FN_OnFreeEntPrivateData(edict_t *pEnt);
+#endif // FN_OnFreeEntPrivateData
+
+#ifdef FN_GameShutdown
+void FN_GameShutdown(void);
+#endif // FN_GameShutdown
+
+#ifdef FN_ShouldCollide
+int FN_ShouldCollide(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_ShouldCollide
+
+
+
+
+
+#ifdef FN_OnFreeEntPrivateData_Post
+void FN_OnFreeEntPrivateData_Post(edict_t *pEnt);
+#endif // FN_OnFreeEntPrivateData_Post
+
+#ifdef FN_GameShutdown_Post
+void FN_GameShutdown_Post(void);
+#endif // FN_GameShutdown_Post
+
+#ifdef FN_ShouldCollide_Post
+int FN_ShouldCollide_Post(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_ShouldCollide_Post
+
+#endif // USE_METAMOD
+
+
+#ifdef FN_AMXX_QUERY
+void FN_AMXX_QUERY(void);
+#endif // FN_AMXX_QUERY
+
+#ifdef FN_AMXX_ATTACH
+void FN_AMXX_ATTACH(void);
+#endif // FN_AMXX_ATTACH
+
+#ifdef FN_AMXX_DETACH
+void FN_AMXX_DETACH(void);
+#endif // FN_AMXX_DETACH
+
+#ifdef FN_AMXX_PLUGINSLOADED
+void FN_AMXX_PLUGINSLOADED(void);
+#endif // FN_AMXX_PLUGINSLOADED
+
+// *** Types ***
+typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/);
+
+// ***** Module funcs stuff *****
+enum ForwardExecType
+{
+ ET_IGNORE = 0, // Ignore return vaue
+ ET_STOP, // Stop on PLUGIN_HANDLED
+ ET_STOP2, // Stop on PLUGIN_HANDLED, continue on other values, return biggest return value
+ ET_CONTINUE, // Continue; return biggest return value
+};
+
+enum ForwardParam
+{
+ FP_DONE = -1, // specify this as the last argument
+ // only tells the function that there are no more arguments
+ FP_CELL, // normal cell
+ FP_FLOAT, // float; used as normal cell though
+ FP_STRING, // string
+ FP_STRINGEX, // string; will be updated to the last function's value
+ FP_ARRAY, // array; use the return value of prepareArray.
+};
+
+
+typedef int (*PFN_ADD_NATIVES) (const AMX_NATIVE_INFO * /*list*/);
+typedef char * (*PFN_BUILD_PATHNAME) (const char * /*format*/, ...);
+typedef char * (*PFN_BUILD_PATHNAME_R) (char * /*buffer*/, size_t /* maxlen */, const char * /* format */, ...);
+typedef cell * (*PFN_GET_AMXADDR) (AMX * /*amx*/, cell /*offset*/);
+typedef void (*PFN_PRINT_SRVCONSOLE) (char * /*format*/, ...);
+typedef const char * (*PFN_GET_MODNAME) (void);
+typedef const char * (*PFN_GET_AMXSCRIPTNAME) (int /*id*/);
+typedef AMX * (*PFN_GET_AMXSCRIPT) (int /*id*/);
+typedef int (*PFN_FIND_AMXSCRIPT_BYAMX) (const AMX * /*amx*/);
+typedef int (*PFN_FIND_AMXSCRIPT_BYNAME) (const char * /*name*/);
+typedef int (*PFN_SET_AMXSTRING) (AMX * /*amx*/, cell /*amx_addr*/, const char * /* source */, int /* max */);
+typedef char * (*PFN_GET_AMXSTRING) (AMX * /*amx*/, cell /*amx_addr*/, int /*bufferId*/, int * /*pLen*/);
+typedef int (*PFN_GET_AMXSTRINGLEN) (const cell *ptr);
+typedef char * (*PFN_FORMAT_AMXSTRING) (AMX * /*amx*/, cell * /*params*/, int /*startParam*/, int * /*pLen*/);
+typedef void (*PFN_COPY_AMXMEMORY) (cell * /*dest*/, const cell * /*src*/, int /*len*/);
+typedef void (*PFN_LOG) (const char * /*fmt*/, ...);
+typedef void (*PFN_LOG_ERROR) (AMX * /*amx*/, int /*err*/, const char * /*fmt*/, ...);
+typedef int (*PFN_RAISE_AMXERROR) (AMX * /*amx*/, int /*error*/);
+typedef int (*PFN_REGISTER_FORWARD) (const char * /*funcname*/, ForwardExecType /*exectype*/, ... /*paramtypes terminated by PF_DONE*/);
+typedef int (*PFN_EXECUTE_FORWARD) (int /*id*/, ... /*params*/);
+typedef cell (*PFN_PREPARE_CELLARRAY) (cell * /*ptr*/, unsigned int /*size*/);
+typedef cell (*PFN_PREPARE_CHARARRAY) (char * /*ptr*/, unsigned int /*size*/);
+typedef cell (*PFN_PREPARE_CELLARRAY_A) (cell * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/);
+typedef cell (*PFN_PREPARE_CHARARRAY_A) (char * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/);
+typedef int (*PFN_IS_PLAYER_VALID) (int /*id*/);
+typedef const char * (*PFN_GET_PLAYER_NAME) (int /*id*/);
+typedef const char * (*PFN_GET_PLAYER_IP) (int /*id*/);
+typedef int (*PFN_IS_PLAYER_INGAME) (int /*id*/);
+typedef int (*PFN_IS_PLAYER_BOT) (int /*id*/);
+typedef int (*PFN_IS_PLAYER_AUTHORIZED) (int /*id*/);
+typedef float (*PFN_GET_PLAYER_TIME) (int /*id*/);
+typedef float (*PFN_GET_PLAYER_PLAYTIME) (int /*id*/);
+typedef int (*PFN_GETPLAYERFLAGS) (int /* id*/);
+typedef int (*PFN_GET_PLAYER_CURWEAPON) (int /*id*/);
+typedef const char * (*PFN_GET_PLAYER_TEAM) (int /*id*/);
+typedef int (*PFN_GET_PLAYER_TEAMID) (int /*id*/);
+typedef int (*PFN_GET_PLAYER_DEATHS) (int /*id*/);
+typedef int (*PFN_GET_PLAYER_MENU) (int /*id*/);
+typedef int (*PFN_GET_PLAYER_KEYS) (int /*id*/);
+typedef int (*PFN_IS_PLAYER_ALIVE) (int /*id*/);
+typedef int (*PFN_GET_PLAYER_FRAGS) (int /*id*/);
+typedef int (*PFN_IS_PLAYER_CONNECTING) (int /*id*/);
+typedef int (*PFN_IS_PLAYER_HLTV) (int /*id*/);
+typedef int (*PFN_GET_PLAYER_ARMOR) (int /*id*/);
+typedef int (*PFN_GET_PLAYER_HEALTH) (int /*id*/);
+#ifdef USE_METAMOD
+typedef edict_t * (*PFN_GET_PLAYER_EDICT) (int /*id*/);
+#else
+typedef void * (*PFN_GET_PLAYER_EDICT) (int /*id*/);
+#endif
+
+#ifdef MEMORY_TEST
+typedef void * (*PFN_ALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
+ const unsigned int /*type*/, const size_t /*size*/);
+typedef void * (*PFN_REALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
+ const unsigned int /*type*/, const size_t /*size*/, void* /*addr*/ );
+typedef void (*PFN_DEALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
+ const unsigned int /*type*/, const void* /*addr*/ );
+#endif
+typedef int (*PFN_AMX_EXEC) (AMX* /*amx*/, cell* /*return val*/, int /*index*/);
+typedef int (*PFN_AMX_EXECV) (AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, cell[] /*params*/);
+typedef int (*PFN_AMX_ALLOT) (AMX* /*amx*/, int /*length*/, cell* /*amx_addr*/, cell** /*phys_addr*/);
+typedef int (*PFN_AMX_FINDPUBLIC) (AMX* /*amx*/, char* /*func name*/, int* /*index*/);
+typedef int (*PFN_AMX_FINDNATIVE) (AMX* /*amx*/, char* /*func name*/, int* /*index*/);
+typedef int (*PFN_LOAD_AMXSCRIPT) (AMX* /*amx*/, void** /*code*/, const char* /*path*/, char[64] /*error info*/, int /* debug */);
+typedef int (*PFN_UNLOAD_AMXSCRIPT) (AMX* /*amx*/,void** /*code*/);
+typedef cell (*PFN_REAL_TO_CELL) (REAL /*x*/);
+typedef REAL (*PFN_CELL_TO_REAL) (cell /*x*/);
+typedef int (*PFN_REGISTER_SPFORWARD) (AMX * /*amx*/, int /*func*/, ... /*params*/);
+typedef int (*PFN_REGISTER_SPFORWARD_BYNAME) (AMX * /*amx*/, const char * /*funcName*/, ... /*params*/);
+typedef void (*PFN_UNREGISTER_SPFORWARD) (int /*id*/);
+typedef void (*PFN_MERGEDEFINITION_FILE) (const char * /*filename*/);
+typedef const char * (*PFN_FORMAT) (const char * /*fmt*/, ... /*params*/);
+typedef void (*PFN_REGISTERFUNCTION) (void * /*pfn*/, const char * /*desc*/);
+typedef int (*PFN_AMX_PUSH) (AMX * /*amx*/, cell /*value*/);
+
+extern PFN_ADD_NATIVES g_fn_AddNatives;
+extern PFN_BUILD_PATHNAME g_fn_BuildPathname;
+extern PFN_BUILD_PATHNAME_R g_fn_BuildPathnameR;
+extern PFN_GET_AMXADDR g_fn_GetAmxAddr;
+extern PFN_PRINT_SRVCONSOLE g_fn_PrintSrvConsole;
+extern PFN_GET_MODNAME g_fn_GetModname;
+extern PFN_GET_AMXSCRIPTNAME g_fn_GetAmxScriptName;
+extern PFN_GET_AMXSCRIPT g_fn_GetAmxScript;
+extern PFN_FIND_AMXSCRIPT_BYAMX g_fn_FindAmxScriptByAmx;
+extern PFN_FIND_AMXSCRIPT_BYNAME g_fn_FindAmxScriptByName;
+extern PFN_SET_AMXSTRING g_fn_SetAmxString;
+extern PFN_GET_AMXSTRING g_fn_GetAmxString;
+extern PFN_GET_AMXSTRINGLEN g_fn_GetAmxStringLen;
+extern PFN_FORMAT_AMXSTRING g_fn_FormatAmxString;
+extern PFN_COPY_AMXMEMORY g_fn_CopyAmxMemory;
+extern PFN_LOG g_fn_Log;
+extern PFN_LOG_ERROR g_fn_LogErrorFunc;
+extern PFN_RAISE_AMXERROR g_fn_RaiseAmxError;
+extern PFN_REGISTER_FORWARD g_fn_RegisterForward;
+extern PFN_EXECUTE_FORWARD g_fn_ExecuteForward;
+extern PFN_PREPARE_CELLARRAY g_fn_PrepareCellArray;
+extern PFN_PREPARE_CHARARRAY g_fn_PrepareCharArray;
+extern PFN_PREPARE_CELLARRAY_A g_fn_PrepareCellArrayA;
+extern PFN_PREPARE_CHARARRAY_A g_fn_PrepareCharArrayA;
+extern PFN_IS_PLAYER_VALID g_fn_IsPlayerValid;
+extern PFN_GET_PLAYER_NAME g_fn_GetPlayerName;
+extern PFN_GET_PLAYER_IP g_fn_GetPlayerIP;
+extern PFN_IS_PLAYER_INGAME g_fn_IsPlayerIngame;
+extern PFN_IS_PLAYER_BOT g_fn_IsPlayerBot;
+extern PFN_IS_PLAYER_AUTHORIZED g_fn_IsPlayerAuthorized;
+extern PFN_GET_PLAYER_TIME g_fn_GetPlayerTime;
+extern PFN_GET_PLAYER_PLAYTIME g_fn_GetPlayerPlayTime;
+extern PFN_GET_PLAYER_CURWEAPON g_fn_GetPlayerCurweapon;
+extern PFN_GET_PLAYER_TEAMID g_fn_GetPlayerTeamID;
+extern PFN_GET_PLAYER_DEATHS g_fn_GetPlayerDeaths;
+extern PFN_GET_PLAYER_MENU g_fn_GetPlayerMenu;
+extern PFN_GET_PLAYER_KEYS g_fn_GetPlayerKeys;
+extern PFN_IS_PLAYER_ALIVE g_fn_IsPlayerAlive;
+extern PFN_GET_PLAYER_FRAGS g_fn_GetPlayerFrags;
+extern PFN_IS_PLAYER_CONNECTING g_fn_IsPlayerConnecting;
+extern PFN_IS_PLAYER_HLTV g_fn_IsPlayerHLTV;
+extern PFN_GET_PLAYER_ARMOR g_fn_GetPlayerArmor;
+extern PFN_GET_PLAYER_HEALTH g_fn_GetPlayerHealth;
+extern PFN_AMX_EXEC g_fn_AmxExec;
+extern PFN_AMX_ALLOT g_fn_AmxAllot;
+extern PFN_AMX_FINDPUBLIC g_fn_AmxFindPublic;
+extern PFN_LOAD_AMXSCRIPT g_fn_LoadAmxScript;
+extern PFN_UNLOAD_AMXSCRIPT g_fn_UnloadAmxScript;
+extern PFN_REAL_TO_CELL g_fn_RealToCell;
+extern PFN_CELL_TO_REAL g_fn_CellToReal;
+extern PFN_REGISTER_SPFORWARD g_fn_RegisterSPForward;
+extern PFN_REGISTER_SPFORWARD_BYNAME g_fn_RegisterSPForwardByName;
+extern PFN_UNREGISTER_SPFORWARD g_fn_UnregisterSPForward;
+extern PFN_MERGEDEFINITION_FILE g_fn_MergeDefinition_File;
+extern PFN_AMX_FINDNATIVE g_fn_AmxFindNative;
+extern PFN_GETPLAYERFLAGS g_fn_GetPlayerFlags;
+extern PFN_GET_PLAYER_EDICT g_fn_GetPlayerEdict;
+extern PFN_FORMAT g_fn_Format;
+extern PFN_GET_PLAYER_TEAM g_fn_GetPlayerTeam;
+extern PFN_REGISTERFUNCTION g_fn_RegisterFunction;
+extern PFN_REQ_FNPTR g_fn_RequestFunction;
+extern PFN_AMX_PUSH g_fn_AmxPush;
+
+#ifdef MAY_NEVER_BE_DEFINED
+// Function prototypes for intellisense and similar systems
+// They understand #if 0 so we use #ifdef MAY_NEVER_BE_DEFINED
+int MF_AddNatives (const AMX_NATIVE_INFO *list) { }
+char * MF_BuildPathname (const char * format, ...) { }
+char * MF_BuildPathnameR (char *buffer, size_t maxlen, const char *fmt, ...) { }
+cell * MF_GetAmxAddr (AMX * amx, cell offset) { }
+void MF_PrintSrvConsole (char * format, ...) { }
+const char * MF_GetModname (void) { }
+const char * MF_GetScriptName (int id) { }
+AMX * MF_GetScriptAmx (int id) { }
+int MF_FindScriptByAmx (const AMX * amx) { }
+int MF_FindScriptByAmx (const char * name) { }
+int MF_SetAmxString (AMX * amx, cell amx_addr, const char * source , int max ) { }
+char * MF_GetAmxString (AMX * amx, cell amx_addr, int bufferId, int * pLen) { }
+int MF_GetAmxStringLen (const cell *ptr) { }
+char * MF_FormatAmxString (AMX * amx, cell * params, int startParam, int * pLen) { }
+void MF_CopyAmxMemory (cell * dest, const cell * src, int len) { }
+void MF_Log (const char * fmt, ...) { }
+void MF_LogError (AMX * amx, int err, const char *fmt, ...) { }
+int MF_RaiseAmxError (AMX * amx, int error) { }
+int MF_RegisterForward (const char * funcname, ForwardExecType exectype, ...) { }
+int MF_ExecuteForward (int id, ...) { }
+cell MF_PrepareCellArray (cell * ptr, unsigned int size) { }
+cell MF_PrepareCharArray (char * ptr, unsigned int size) { }
+cell MF_PrepareCellArrayA (cell * ptr, unsigned int size, bool copyBack) { }
+cell MF_PrepareCharArrayA (char * ptr, unsigned int size, bool copyBack) { }
+int MF_IsPlayerValid (int id) { }
+const char * MF_GetPlayerName (int id) { }
+const char * MF_GetPlayerIP (int id) { }
+int MF_IsPlayerIngame (int id) { }
+int MF_IsPlayerBot (int id) { }
+int MF_IsPlayerAuthorized (int id) { }
+float MF_GetPlayerTime (int id) { }
+float MF_GetPlayerPlayTime (int id) { }
+int MF_GetPlayerCurweapon (int id) { }
+const char * MF_GetPlayerTeam (int id) { }
+int MF_GetPlayerTeamID (int id) { }
+int MF_GetPlayerDeaths (int id) { }
+int MF_GetPlayerMenu (int id) { }
+int MF_GetPlayerKeys (int id) { }
+int MF_IsPlayerAlive (int id) { }
+int MF_GetPlayerFrags (int id) { }
+int MF_IsPlayerConnecting (int id) { }
+int MF_IsPlayerHLTV (int id) { }
+int MF_GetPlayerArmor (int id) { }
+int MF_GetPlayerHealth (int id) { }
+REAL amx_ctof (cell x) { }
+cell amx_ftoc (float x) { }
+int MF_RegisterSPForwardByName (AMX * amx, const char *str, ...) { }
+int MF_RegisterSPForward (AMX * amx, int func, ...) { }
+void MF_UnregisterSPForward (int id) { }
+int MF_GetPlayerFlags (int id) { }
+edict_t* MF_GetPlayerEdict (int id) { }
+const char * MF_Format (const char *fmt, ...) { }
+void MF_RegisterFunction (void *pfn, const char *description) { }
+void * MF_RequestFunction (const char *description) { }
+int MF_AmxPush (AMX *amx, cell *params) { }
+int MF_AmxExec (AMX *amx, cell *retval, int idx) { }
+#endif // MAY_NEVER_BE_DEFINED
+
+#define MF_AddNatives g_fn_AddNatives
+#define MF_BuildPathname g_fn_BuildPathname
+#define MF_BuildPathnameR g_fn_BuildPathnameR
+#define MF_FormatAmxString g_fn_FormatAmxString
+#define MF_GetAmxAddr g_fn_GetAmxAddr
+#define MF_PrintSrvConsole g_fn_PrintSrvConsole
+#define MF_GetModname g_fn_GetModname
+#define MF_GetScriptName g_fn_GetAmxScriptName
+#define MF_GetScriptAmx g_fn_GetAmxScript
+#define MF_FindScriptByAmx g_fn_FindAmxScriptByAmx
+#define MF_FindScriptByName g_fn_FindAmxScriptByName
+#define MF_SetAmxString g_fn_SetAmxString
+#define MF_GetAmxString g_fn_GetAmxString
+#define MF_GetAmxStringLen g_fn_GetAmxStringLen
+#define MF_CopyAmxMemory g_fn_CopyAmxMemory
+void MF_Log(const char *fmt, ...);
+void MF_LogError(AMX *amx, int err, const char *fmt, ...);
+#define MF_RaiseAmxError g_fn_RaiseAmxError
+#define MF_RegisterForward g_fn_RegisterForward
+#define MF_ExecuteForward g_fn_ExecuteForward
+#define MF_PrepareCellArray g_fn_PrepareCellArray
+#define MF_PrepareCharArray g_fn_PrepareCharArray
+#define MF_PrepareCellArrayA g_fn_PrepareCellArrayA
+#define MF_PrepareCharArrayA g_fn_PrepareCharArrayA
+#define MF_IsPlayerValid g_fn_IsPlayerValid
+#define MF_GetPlayerName g_fn_GetPlayerName
+#define MF_GetPlayerIP g_fn_GetPlayerIP
+#define MF_IsPlayerIngame g_fn_IsPlayerIngame
+#define MF_IsPlayerBot g_fn_IsPlayerBot
+#define MF_IsPlayerAuthorized g_fn_IsPlayerAuthorized
+#define MF_GetPlayerTime g_fn_GetPlayerTime
+#define MF_GetPlayerPlayTime g_fn_GetPlayerPlayTime
+#define MF_GetPlayerCurweapon g_fn_GetPlayerCurweapon
+#define MF_GetPlayerTeam g_fn_GetPlayerTeam
+#define MF_GetPlayerTeamID g_fn_GetPlayerTeamID
+#define MF_GetPlayerDeaths g_fn_GetPlayerDeaths
+#define MF_GetPlayerMenu g_fn_GetPlayerMenu
+#define MF_GetPlayerKeys g_fn_GetPlayerKeys
+#define MF_IsPlayerAlive g_fn_IsPlayerAlive
+#define MF_GetPlayerFrags g_fn_GetPlayerFrags
+#define MF_IsPlayerConnecting g_fn_IsPlayerConnecting
+#define MF_IsPlayerHLTV g_fn_IsPlayerHLTV
+#define MF_GetPlayerArmor g_fn_GetPlayerArmor
+#define MF_GetPlayerHealth g_fn_GetPlayerHealth
+#define MF_AmxExec g_fn_AmxExec
+#define MF_AmxExecv g_fn_AmxExecv
+#define MF_AmxFindPublic g_fn_AmxFindPublic
+#define MF_AmxAllot g_fn_AmxAllot
+#define MF_AmxFindNative g_fn_AmxFindNative
+#define MF_LoadAmxScript g_fn_LoadAmxScript
+#define MF_UnloadAmxScript g_fn_UnloadAmxScript
+#define MF_MergeDefinitionFile g_fn_MergeDefinition_File
+#define amx_ctof g_fn_CellToReal
+#define amx_ftoc g_fn_RealToCell
+#define MF_RegisterSPForwardByName g_fn_RegisterSPForwardByName
+#define MF_RegisterSPForward g_fn_RegisterSPForward
+#define MF_UnregisterSPForward g_fn_UnregisterSPForward
+#define MF_GetPlayerFlags g_fn_GetPlayerFlags
+#define MF_GetPlayerEdict g_fn_GetPlayerEdict
+#define MF_Format g_fn_Format
+#define MF_RegisterFunction g_fn_RegisterFunction
+#define MF_RequestFunction g_fn_RequestFunction;
+#define MF_AmxPush g_fn_AmxPush
+
+#ifdef MEMORY_TEST
+/*** Memory ***/
+void *operator new(size_t reportedSize);
+void *operator new[](size_t reportedSize);
+void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine);
+void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine);
+void operator delete(void *reportedAddress);
+void operator delete[](void *reportedAddress);
+
+// Allocation types
+extern const unsigned int m_alloc_unknown;
+extern const unsigned int m_alloc_new;
+extern const unsigned int m_alloc_new_array;
+extern const unsigned int m_alloc_malloc;
+extern const unsigned int m_alloc_calloc;
+extern const unsigned int m_alloc_realloc;
+extern const unsigned int m_alloc_delete;
+extern const unsigned int m_alloc_delete_array;
+extern const unsigned int m_alloc_free;
+
+// To be called before new / delete
+void Mem_SetOwner(const char *filename, int line, const char *function);
+// Actual allocator
+void * Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+ const unsigned int allocationType, const size_t reportedSize);
+void * Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+ const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress);
+void Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+ const unsigned int deallocationType, void *reportedAddress);
+
+// memory macros
+#ifndef __FUNCTION__
+#define __FUNCTION__ "??"
+#endif
+
+// call Mem_SetOwner, followed by the actual new operator
+#define new (Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? NULL : new
+// call Mem_SetOwner, followed by the actual delete operator
+#define delete (Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? Mem_SetOwner("",0,"") : delete
+#define malloc(sz) Mem_Allocator (__FILE__,__LINE__,__FUNCTION__,m_alloc_malloc,sz)
+#define calloc(sz) Mem_Allocator (__FILE__,__LINE__,__FUNCTION__,m_alloc_calloc,sz)
+#define realloc(ptr,sz) Mem_Reallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_realloc,sz,ptr)
+#define free(ptr) Mem_Deallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_free,ptr)
+
+#endif //MEMORY_TEST
+
+#endif // #ifndef __AMXXMODULE_H__
diff --git a/dlls/arrayx/moduleconfig.h b/dlls/arrayx/moduleconfig.h
new file mode 100644
index 00000000..cc25d269
--- /dev/null
+++ b/dlls/arrayx/moduleconfig.h
@@ -0,0 +1,463 @@
+// Configuration
+
+#ifndef __MODULECONFIG_H__
+#define __MODULECONFIG_H__
+
+// Module info
+#define MODULE_NAME "Array"
+#define MODULE_VERSION "1.7"
+#define MODULE_AUTHOR "Twilight Suzuka"
+#define MODULE_URL "www.amxmodx.org"
+#define MODULE_LOGTAG "ARRAY"
+// If you want the module not to be reloaded on mapchange, remove / comment out the next line
+#define MODULE_RELOAD_ON_MAPCHANGE
+
+#ifdef __DATE__
+#define MODULE_DATE __DATE__
+#else // __DATE__
+#define MODULE_DATE "Unknown"
+#endif // __DATE__
+
+// metamod plugin?
+//#define USE_METAMOD
+
+// - AMXX Init functions
+// Also consider using FN_META_*
+// AMXX query
+//#define FN_AMXX_QUERY OnAmxxQuery
+// AMXX attach
+// Do native functions init here (MF_AddNatives)
+#define FN_AMXX_ATTACH OnAmxxAttach
+// AMXX dettach
+#define FN_AMXX_DETTACH OnAmxxDettach
+// All plugins loaded
+// Do forward functions init here (MF_RegisterForward)
+// #define FN_AMXX_PLUGINSLOADED OnPluginsLoaded
+
+/**** METAMOD ****/
+// If your module doesn't use metamod, you may close the file now :)
+#ifdef USE_METAMOD
+// ----
+// Hook Functions
+// Uncomment these to be called
+// You can also change the function name
+
+// - Metamod init functions
+// Also consider using FN_AMXX_*
+// Meta query
+//#define FN_META_QUERY OnMetaQuery
+// Meta attach
+//#define FN_META_ATTACH OnMetaAttach
+// Meta dettach
+//#define FN_META_DETTACH OnMetaDettach
+
+// (wd) are Will Day's notes
+// - GetEntityAPI2 functions
+// #define FN_GameDLLInit GameDLLInit /* pfnGameInit() */
+// #define FN_DispatchSpawn DispatchSpawn /* pfnSpawn() */
+// #define FN_DispatchThink DispatchThink /* pfnThink() */
+// #define FN_DispatchUse DispatchUse /* pfnUse() */
+// #define FN_DispatchTouch DispatchTouch /* pfnTouch() */
+// #define FN_DispatchBlocked DispatchBlocked /* pfnBlocked() */
+// #define FN_DispatchKeyValue DispatchKeyValue /* pfnKeyValue() */
+// #define FN_DispatchSave DispatchSave /* pfnSave() */
+// #define FN_DispatchRestore DispatchRestore /* pfnRestore() */
+// #define FN_DispatchObjectCollsionBox DispatchObjectCollsionBox /* pfnSetAbsBox() */
+// #define FN_SaveWriteFields SaveWriteFields /* pfnSaveWriteFields() */
+// #define FN_SaveReadFields SaveReadFields /* pfnSaveReadFields() */
+// #define FN_SaveGlobalState SaveGlobalState /* pfnSaveGlobalState() */
+// #define FN_RestoreGlobalState RestoreGlobalState /* pfnRestoreGlobalState() */
+// #define FN_ResetGlobalState ResetGlobalState /* pfnResetGlobalState() */
+// #define FN_ClientConnect ClientConnect /* pfnClientConnect() (wd) Client has connected */
+// #define FN_ClientDisconnect ClientDisconnect /* pfnClientDisconnect() (wd) Player has left the game */
+// #define FN_ClientKill ClientKill /* pfnClientKill() (wd) Player has typed "kill" */
+// #define FN_ClientPutInServer ClientPutInServer /* pfnClientPutInServer() (wd) Client is entering the game */
+// #define FN_ClientCommand ClientCommand /* pfnClientCommand() (wd) Player has sent a command (typed or from a bind) */
+// #define FN_ClientUserInfoChanged ClientUserInfoChanged /* pfnClientUserInfoChanged() (wd) Client has updated their setinfo structure */
+// #define FN_ServerActivate ServerActivate /* pfnServerActivate() (wd) Server is starting a new map */
+// #define FN_ServerDeactivate ServerDeactivate /* pfnServerDeactivate() (wd) Server is leaving the map (shutdown or changelevel); SDK2 */
+// #define FN_PlayerPreThink PlayerPreThink /* pfnPlayerPreThink() */
+// #define FN_PlayerPostThink PlayerPostThink /* pfnPlayerPostThink() */
+// #define FN_StartFrame StartFrame /* pfnStartFrame() */
+// #define FN_ParmsNewLevel ParmsNewLevel /* pfnParmsNewLevel() */
+// #define FN_ParmsChangeLevel ParmsChangeLevel /* pfnParmsChangeLevel() */
+// #define FN_GetGameDescription GetGameDescription /* pfnGetGameDescription() Returns string describing current .dll. E.g. "TeamFotrress 2" "Half-Life" */
+// #define FN_PlayerCustomization PlayerCustomization /* pfnPlayerCustomization() Notifies .dll of new customization for player. */
+// #define FN_SpectatorConnect SpectatorConnect /* pfnSpectatorConnect() Called when spectator joins server */
+// #define FN_SpectatorDisconnect SpectatorDisconnect /* pfnSpectatorDisconnect() Called when spectator leaves the server */
+// #define FN_SpectatorThink SpectatorThink /* pfnSpectatorThink() Called when spectator sends a command packet (usercmd_t) */
+// #define FN_Sys_Error Sys_Error /* pfnSys_Error() Notify game .dll that engine is going to shut down. Allows mod authors to set a breakpoint. SDK2 */
+// #define FN_PM_Move PM_Move /* pfnPM_Move() (wd) SDK2 */
+// #define FN_PM_Init PM_Init /* pfnPM_Init() Server version of player movement initialization; (wd) SDK2 */
+// #define FN_PM_FindTextureType PM_FindTextureType /* pfnPM_FindTextureType() (wd) SDK2 */
+// #define FN_SetupVisibility SetupVisibility /* pfnSetupVisibility() Set up PVS and PAS for networking for this client; (wd) SDK2 */
+// #define FN_UpdateClientData UpdateClientData /* pfnUpdateClientData() Set up data sent only to specific client; (wd) SDK2 */
+// #define FN_AddToFullPack AddToFullPack /* pfnAddToFullPack() (wd) SDK2 */
+// #define FN_CreateBaseline CreateBaseline /* pfnCreateBaseline() Tweak entity baseline for network encoding allows setup of player baselines too.; (wd) SDK2 */
+// #define FN_RegisterEncoders RegisterEncoders /* pfnRegisterEncoders() Callbacks for network encoding; (wd) SDK2 */
+// #define FN_GetWeaponData GetWeaponData /* pfnGetWeaponData() (wd) SDK2 */
+// #define FN_CmdStart CmdStart /* pfnCmdStart() (wd) SDK2 */
+// #define FN_CmdEnd CmdEnd /* pfnCmdEnd() (wd) SDK2 */
+// #define FN_ConnectionlessPacket ConnectionlessPacket /* pfnConnectionlessPacket() (wd) SDK2 */
+// #define FN_GetHullBounds GetHullBounds /* pfnGetHullBounds() (wd) SDK2 */
+// #define FN_CreateInstancedBaselines CreateInstancedBaselines /* pfnCreateInstancedBaselines() (wd) SDK2 */
+// #define FN_InconsistentFile InconsistentFile /* pfnInconsistentFile() (wd) SDK2 */
+// #define FN_AllowLagCompensation AllowLagCompensation /* pfnAllowLagCompensation() (wd) SDK2 */
+
+// - GetEntityAPI2_Post functions
+// #define FN_GameDLLInit_Post GameDLLInit_Post
+// #define FN_DispatchSpawn_Post DispatchSpawn_Post
+// #define FN_DispatchThink_Post DispatchThink_Post
+// #define FN_DispatchUse_Post DispatchUse_Post
+// #define FN_DispatchTouch_Post DispatchTouch_Post
+// #define FN_DispatchBlocked_Post DispatchBlocked_Post
+// #define FN_DispatchKeyValue_Post DispatchKeyValue_Post
+// #define FN_DispatchSave_Post DispatchSave_Post
+// #define FN_DispatchRestore_Post DispatchRestore_Post
+// #define FN_DispatchObjectCollsionBox_Post DispatchObjectCollsionBox_Post
+// #define FN_SaveWriteFields_Post SaveWriteFields_Post
+// #define FN_SaveReadFields_Post SaveReadFields_Post
+// #define FN_SaveGlobalState_Post SaveGlobalState_Post
+// #define FN_RestoreGlobalState_Post RestoreGlobalState_Post
+// #define FN_ResetGlobalState_Post ResetGlobalState_Post
+// #define FN_ClientConnect_Post ClientConnect_Post
+// #define FN_ClientDisconnect_Post ClientDisconnect_Post
+// #define FN_ClientKill_Post ClientKill_Post
+// #define FN_ClientPutInServer_Post ClientPutInServer_Post
+// #define FN_ClientCommand_Post ClientCommand_Post
+// #define FN_ClientUserInfoChanged_Post ClientUserInfoChanged_Post
+// #define FN_ServerActivate_Post ServerActivate_Post
+// #define FN_ServerDeactivate_Post ServerDeactivate_Post
+// #define FN_PlayerPreThink_Post PlayerPreThink_Post
+// #define FN_PlayerPostThink_Post PlayerPostThink_Post
+// #define FN_StartFrame_Post StartFrame_Post
+// #define FN_ParmsNewLevel_Post ParmsNewLevel_Post
+// #define FN_ParmsChangeLevel_Post ParmsChangeLevel_Post
+// #define FN_GetGameDescription_Post GetGameDescription_Post
+// #define FN_PlayerCustomization_Post PlayerCustomization_Post
+// #define FN_SpectatorConnect_Post SpectatorConnect_Post
+// #define FN_SpectatorDisconnect_Post SpectatorDisconnect_Post
+// #define FN_SpectatorThink_Post SpectatorThink_Post
+// #define FN_Sys_Error_Post Sys_Error_Post
+// #define FN_PM_Move_Post PM_Move_Post
+// #define FN_PM_Init_Post PM_Init_Post
+// #define FN_PM_FindTextureType_Post PM_FindTextureType_Post
+// #define FN_SetupVisibility_Post SetupVisibility_Post
+// #define FN_UpdateClientData_Post UpdateClientData_Post
+// #define FN_AddToFullPack_Post AddToFullPack_Post
+// #define FN_CreateBaseline_Post CreateBaseline_Post
+// #define FN_RegisterEncoders_Post RegisterEncoders_Post
+// #define FN_GetWeaponData_Post GetWeaponData_Post
+// #define FN_CmdStart_Post CmdStart_Post
+// #define FN_CmdEnd_Post CmdEnd_Post
+// #define FN_ConnectionlessPacket_Post ConnectionlessPacket_Post
+// #define FN_GetHullBounds_Post GetHullBounds_Post
+// #define FN_CreateInstancedBaselines_Post CreateInstancedBaselines_Post
+// #define FN_InconsistentFile_Post InconsistentFile_Post
+// #define FN_AllowLagCompensation_Post AllowLagCompensation_Post
+
+// - GetEngineAPI functions
+// #define FN_PrecacheModel PrecacheModel
+// #define FN_PrecacheSound PrecacheSound
+// #define FN_SetModel SetModel
+// #define FN_ModelIndex ModelIndex
+// #define FN_ModelFrames ModelFrames
+// #define FN_SetSize SetSize
+// #define FN_ChangeLevel ChangeLevel
+// #define FN_GetSpawnParms GetSpawnParms
+// #define FN_SaveSpawnParms SaveSpawnParms
+// #define FN_VecToYaw VecToYaw
+// #define FN_VecToAngles VecToAngles
+// #define FN_MoveToOrigin MoveToOrigin
+// #define FN_ChangeYaw ChangeYaw
+// #define FN_ChangePitch ChangePitch
+// #define FN_FindEntityByString FindEntityByString
+// #define FN_GetEntityIllum GetEntityIllum
+// #define FN_FindEntityInSphere FindEntityInSphere
+// #define FN_FindClientInPVS FindClientInPVS
+// #define FN_EntitiesInPVS EntitiesInPVS
+// #define FN_MakeVectors MakeVectors
+// #define FN_AngleVectors AngleVectors
+// #define FN_CreateEntity CreateEntity
+// #define FN_RemoveEntity RemoveEntity
+// #define FN_CreateNamedEntity CreateNamedEntity
+// #define FN_MakeStatic MakeStatic
+// #define FN_EntIsOnFloor EntIsOnFloor
+// #define FN_DropToFloor DropToFloor
+// #define FN_WalkMove WalkMove
+// #define FN_SetOrigin SetOrigin
+// #define FN_EmitSound EmitSound
+// #define FN_EmitAmbientSound EmitAmbientSound
+// #define FN_TraceLine TraceLine
+// #define FN_TraceToss TraceToss
+// #define FN_TraceMonsterHull TraceMonsterHull
+// #define FN_TraceHull TraceHull
+// #define FN_TraceModel TraceModel
+// #define FN_TraceTexture TraceTexture
+// #define FN_TraceSphere TraceSphere
+// #define FN_GetAimVector GetAimVector
+// #define FN_ServerCommand ServerCommand
+// #define FN_ServerExecute ServerExecute
+// #define FN_engClientCommand engClientCommand
+// #define FN_ParticleEffect ParticleEffect
+// #define FN_LightStyle LightStyle
+// #define FN_DecalIndex DecalIndex
+// #define FN_PointContents PointContents
+// #define FN_MessageBegin MessageBegin
+// #define FN_MessageEnd MessageEnd
+// #define FN_WriteByte WriteByte
+// #define FN_WriteChar WriteChar
+// #define FN_WriteShort WriteShort
+// #define FN_WriteLong WriteLong
+// #define FN_WriteAngle WriteAngle
+// #define FN_WriteCoord WriteCoord
+// #define FN_WriteString WriteString
+// #define FN_WriteEntity WriteEntity
+// #define FN_CVarRegister CVarRegister
+// #define FN_CVarGetFloat CVarGetFloat
+// #define FN_CVarGetString CVarGetString
+// #define FN_CVarSetFloat CVarSetFloat
+// #define FN_CVarSetString CVarSetString
+// #define FN_AlertMessage AlertMessage
+// #define FN_EngineFprintf EngineFprintf
+// #define FN_PvAllocEntPrivateData PvAllocEntPrivateData
+// #define FN_PvEntPrivateData PvEntPrivateData
+// #define FN_FreeEntPrivateData FreeEntPrivateData
+// #define FN_SzFromIndex SzFromIndex
+// #define FN_AllocString AllocString
+// #define FN_GetVarsOfEnt GetVarsOfEnt
+// #define FN_PEntityOfEntOffset PEntityOfEntOffset
+// #define FN_EntOffsetOfPEntity EntOffsetOfPEntity
+// #define FN_IndexOfEdict IndexOfEdict
+// #define FN_PEntityOfEntIndex PEntityOfEntIndex
+// #define FN_FindEntityByVars FindEntityByVars
+// #define FN_GetModelPtr GetModelPtr
+// #define FN_RegUserMsg RegUserMsg
+// #define FN_AnimationAutomove AnimationAutomove
+// #define FN_GetBonePosition GetBonePosition
+// #define FN_FunctionFromName FunctionFromName
+// #define FN_NameForFunction NameForFunction
+// #define FN_ClientPrintf ClientPrintf
+// #define FN_ServerPrint ServerPrint
+// #define FN_Cmd_Args Cmd_Args
+// #define FN_Cmd_Argv Cmd_Argv
+// #define FN_Cmd_Argc Cmd_Argc
+// #define FN_GetAttachment GetAttachment
+// #define FN_CRC32_Init CRC32_Init
+// #define FN_CRC32_ProcessBuffer CRC32_ProcessBuffer
+// #define FN_CRC32_ProcessByte CRC32_ProcessByte
+// #define FN_CRC32_Final CRC32_Final
+// #define FN_RandomLong RandomLong
+// #define FN_RandomFloat RandomFloat
+// #define FN_SetView SetView
+// #define FN_Time Time
+// #define FN_CrosshairAngle CrosshairAngle
+// #define FN_LoadFileForMe LoadFileForMe
+// #define FN_FreeFile FreeFile
+// #define FN_EndSection EndSection
+// #define FN_CompareFileTime CompareFileTime
+// #define FN_GetGameDir GetGameDir
+// #define FN_Cvar_RegisterVariable Cvar_RegisterVariable
+// #define FN_FadeClientVolume FadeClientVolume
+// #define FN_SetClientMaxspeed SetClientMaxspeed
+// #define FN_CreateFakeClient CreateFakeClient
+// #define FN_RunPlayerMove RunPlayerMove
+// #define FN_NumberOfEntities NumberOfEntities
+// #define FN_GetInfoKeyBuffer GetInfoKeyBuffer
+// #define FN_InfoKeyValue InfoKeyValue
+// #define FN_SetKeyValue SetKeyValue
+// #define FN_SetClientKeyValue SetClientKeyValue
+// #define FN_IsMapValid IsMapValid
+// #define FN_StaticDecal StaticDecal
+// #define FN_PrecacheGeneric PrecacheGeneric
+// #define FN_GetPlayerUserId GetPlayerUserId
+// #define FN_BuildSoundMsg BuildSoundMsg
+// #define FN_IsDedicatedServer IsDedicatedServer
+// #define FN_CVarGetPointer CVarGetPointer
+// #define FN_GetPlayerWONId GetPlayerWONId
+// #define FN_Info_RemoveKey Info_RemoveKey
+// #define FN_GetPhysicsKeyValue GetPhysicsKeyValue
+// #define FN_SetPhysicsKeyValue SetPhysicsKeyValue
+// #define FN_GetPhysicsInfoString GetPhysicsInfoString
+// #define FN_PrecacheEvent PrecacheEvent
+// #define FN_PlaybackEvent PlaybackEvent
+// #define FN_SetFatPVS SetFatPVS
+// #define FN_SetFatPAS SetFatPAS
+// #define FN_CheckVisibility CheckVisibility
+// #define FN_DeltaSetField DeltaSetField
+// #define FN_DeltaUnsetField DeltaUnsetField
+// #define FN_DeltaAddEncoder DeltaAddEncoder
+// #define FN_GetCurrentPlayer GetCurrentPlayer
+// #define FN_CanSkipPlayer CanSkipPlayer
+// #define FN_DeltaFindField DeltaFindField
+// #define FN_DeltaSetFieldByIndex DeltaSetFieldByIndex
+// #define FN_DeltaUnsetFieldByIndex DeltaUnsetFieldByIndex
+// #define FN_SetGroupMask SetGroupMask
+// #define FN_engCreateInstancedBaseline engCreateInstancedBaseline
+// #define FN_Cvar_DirectSet Cvar_DirectSet
+// #define FN_ForceUnmodified ForceUnmodified
+// #define FN_GetPlayerStats GetPlayerStats
+// #define FN_AddServerCommand AddServerCommand
+// #define FN_Voice_GetClientListening Voice_GetClientListening
+// #define FN_Voice_SetClientListening Voice_SetClientListening
+// #define FN_GetPlayerAuthId GetPlayerAuthId
+
+// - GetEngineAPI_Post functions
+// #define FN_PrecacheModel_Post PrecacheModel_Post
+// #define FN_PrecacheSound_Post PrecacheSound_Post
+// #define FN_SetModel_Post SetModel_Post
+// #define FN_ModelIndex_Post ModelIndex_Post
+// #define FN_ModelFrames_Post ModelFrames_Post
+// #define FN_SetSize_Post SetSize_Post
+// #define FN_ChangeLevel_Post ChangeLevel_Post
+// #define FN_GetSpawnParms_Post GetSpawnParms_Post
+// #define FN_SaveSpawnParms_Post SaveSpawnParms_Post
+// #define FN_VecToYaw_Post VecToYaw_Post
+// #define FN_VecToAngles_Post VecToAngles_Post
+// #define FN_MoveToOrigin_Post MoveToOrigin_Post
+// #define FN_ChangeYaw_Post ChangeYaw_Post
+// #define FN_ChangePitch_Post ChangePitch_Post
+// #define FN_FindEntityByString_Post FindEntityByString_Post
+// #define FN_GetEntityIllum_Post GetEntityIllum_Post
+// #define FN_FindEntityInSphere_Post FindEntityInSphere_Post
+// #define FN_FindClientInPVS_Post FindClientInPVS_Post
+// #define FN_EntitiesInPVS_Post EntitiesInPVS_Post
+// #define FN_MakeVectors_Post MakeVectors_Post
+// #define FN_AngleVectors_Post AngleVectors_Post
+// #define FN_CreateEntity_Post CreateEntity_Post
+// #define FN_RemoveEntity_Post RemoveEntity_Post
+// #define FN_CreateNamedEntity_Post CreateNamedEntity_Post
+// #define FN_MakeStatic_Post MakeStatic_Post
+// #define FN_EntIsOnFloor_Post EntIsOnFloor_Post
+// #define FN_DropToFloor_Post DropToFloor_Post
+// #define FN_WalkMove_Post WalkMove_Post
+// #define FN_SetOrigin_Post SetOrigin_Post
+// #define FN_EmitSound_Post EmitSound_Post
+// #define FN_EmitAmbientSound_Post EmitAmbientSound_Post
+// #define FN_TraceLine_Post TraceLine_Post
+// #define FN_TraceToss_Post TraceToss_Post
+// #define FN_TraceMonsterHull_Post TraceMonsterHull_Post
+// #define FN_TraceHull_Post TraceHull_Post
+// #define FN_TraceModel_Post TraceModel_Post
+// #define FN_TraceTexture_Post TraceTexture_Post
+// #define FN_TraceSphere_Post TraceSphere_Post
+// #define FN_GetAimVector_Post GetAimVector_Post
+// #define FN_ServerCommand_Post ServerCommand_Post
+// #define FN_ServerExecute_Post ServerExecute_Post
+// #define FN_engClientCommand_Post engClientCommand_Post
+// #define FN_ParticleEffect_Post ParticleEffect_Post
+// #define FN_LightStyle_Post LightStyle_Post
+// #define FN_DecalIndex_Post DecalIndex_Post
+// #define FN_PointContents_Post PointContents_Post
+// #define FN_MessageBegin_Post MessageBegin_Post
+// #define FN_MessageEnd_Post MessageEnd_Post
+// #define FN_WriteByte_Post WriteByte_Post
+// #define FN_WriteChar_Post WriteChar_Post
+// #define FN_WriteShort_Post WriteShort_Post
+// #define FN_WriteLong_Post WriteLong_Post
+// #define FN_WriteAngle_Post WriteAngle_Post
+// #define FN_WriteCoord_Post WriteCoord_Post
+// #define FN_WriteString_Post WriteString_Post
+// #define FN_WriteEntity_Post WriteEntity_Post
+// #define FN_CVarRegister_Post CVarRegister_Post
+// #define FN_CVarGetFloat_Post CVarGetFloat_Post
+// #define FN_CVarGetString_Post CVarGetString_Post
+// #define FN_CVarSetFloat_Post CVarSetFloat_Post
+// #define FN_CVarSetString_Post CVarSetString_Post
+// #define FN_AlertMessage_Post AlertMessage_Post
+// #define FN_EngineFprintf_Post EngineFprintf_Post
+// #define FN_PvAllocEntPrivateData_Post PvAllocEntPrivateData_Post
+// #define FN_PvEntPrivateData_Post PvEntPrivateData_Post
+// #define FN_FreeEntPrivateData_Post FreeEntPrivateData_Post
+// #define FN_SzFromIndex_Post SzFromIndex_Post
+// #define FN_AllocString_Post AllocString_Post
+// #define FN_GetVarsOfEnt_Post GetVarsOfEnt_Post
+// #define FN_PEntityOfEntOffset_Post PEntityOfEntOffset_Post
+// #define FN_EntOffsetOfPEntity_Post EntOffsetOfPEntity_Post
+// #define FN_IndexOfEdict_Post IndexOfEdict_Post
+// #define FN_PEntityOfEntIndex_Post PEntityOfEntIndex_Post
+// #define FN_FindEntityByVars_Post FindEntityByVars_Post
+// #define FN_GetModelPtr_Post GetModelPtr_Post
+// #define FN_RegUserMsg_Post RegUserMsg_Post
+// #define FN_AnimationAutomove_Post AnimationAutomove_Post
+// #define FN_GetBonePosition_Post GetBonePosition_Post
+// #define FN_FunctionFromName_Post FunctionFromName_Post
+// #define FN_NameForFunction_Post NameForFunction_Post
+// #define FN_ClientPrintf_Post ClientPrintf_Post
+// #define FN_ServerPrint_Post ServerPrint_Post
+// #define FN_Cmd_Args_Post Cmd_Args_Post
+// #define FN_Cmd_Argv_Post Cmd_Argv_Post
+// #define FN_Cmd_Argc_Post Cmd_Argc_Post
+// #define FN_GetAttachment_Post GetAttachment_Post
+// #define FN_CRC32_Init_Post CRC32_Init_Post
+// #define FN_CRC32_ProcessBuffer_Post CRC32_ProcessBuffer_Post
+// #define FN_CRC32_ProcessByte_Post CRC32_ProcessByte_Post
+// #define FN_CRC32_Final_Post CRC32_Final_Post
+// #define FN_RandomLong_Post RandomLong_Post
+// #define FN_RandomFloat_Post RandomFloat_Post
+// #define FN_SetView_Post SetView_Post
+// #define FN_Time_Post Time_Post
+// #define FN_CrosshairAngle_Post CrosshairAngle_Post
+// #define FN_LoadFileForMe_Post LoadFileForMe_Post
+// #define FN_FreeFile_Post FreeFile_Post
+// #define FN_EndSection_Post EndSection_Post
+// #define FN_CompareFileTime_Post CompareFileTime_Post
+// #define FN_GetGameDir_Post GetGameDir_Post
+// #define FN_Cvar_RegisterVariable_Post Cvar_RegisterVariable_Post
+// #define FN_FadeClientVolume_Post FadeClientVolume_Post
+// #define FN_SetClientMaxspeed_Post SetClientMaxspeed_Post
+// #define FN_CreateFakeClient_Post CreateFakeClient_Post
+// #define FN_RunPlayerMove_Post RunPlayerMove_Post
+// #define FN_NumberOfEntities_Post NumberOfEntities_Post
+// #define FN_GetInfoKeyBuffer_Post GetInfoKeyBuffer_Post
+// #define FN_InfoKeyValue_Post InfoKeyValue_Post
+// #define FN_SetKeyValue_Post SetKeyValue_Post
+// #define FN_SetClientKeyValue_Post SetClientKeyValue_Post
+// #define FN_IsMapValid_Post IsMapValid_Post
+// #define FN_StaticDecal_Post StaticDecal_Post
+// #define FN_PrecacheGeneric_Post PrecacheGeneric_Post
+// #define FN_GetPlayerUserId_Post GetPlayerUserId_Post
+// #define FN_BuildSoundMsg_Post BuildSoundMsg_Post
+// #define FN_IsDedicatedServer_Post IsDedicatedServer_Post
+// #define FN_CVarGetPointer_Post CVarGetPointer_Post
+// #define FN_GetPlayerWONId_Post GetPlayerWONId_Post
+// #define FN_Info_RemoveKey_Post Info_RemoveKey_Post
+// #define FN_GetPhysicsKeyValue_Post GetPhysicsKeyValue_Post
+// #define FN_SetPhysicsKeyValue_Post SetPhysicsKeyValue_Post
+// #define FN_GetPhysicsInfoString_Post GetPhysicsInfoString_Post
+// #define FN_PrecacheEvent_Post PrecacheEvent_Post
+// #define FN_PlaybackEvent_Post PlaybackEvent_Post
+// #define FN_SetFatPVS_Post SetFatPVS_Post
+// #define FN_SetFatPAS_Post SetFatPAS_Post
+// #define FN_CheckVisibility_Post CheckVisibility_Post
+// #define FN_DeltaSetField_Post DeltaSetField_Post
+// #define FN_DeltaUnsetField_Post DeltaUnsetField_Post
+// #define FN_DeltaAddEncoder_Post DeltaAddEncoder_Post
+// #define FN_GetCurrentPlayer_Post GetCurrentPlayer_Post
+// #define FN_CanSkipPlayer_Post CanSkipPlayer_Post
+// #define FN_DeltaFindField_Post DeltaFindField_Post
+// #define FN_DeltaSetFieldByIndex_Post DeltaSetFieldByIndex_Post
+// #define FN_DeltaUnsetFieldByIndex_Post DeltaUnsetFieldByIndex_Post
+// #define FN_SetGroupMask_Post SetGroupMask_Post
+// #define FN_engCreateInstancedBaseline_Post engCreateInstancedBaseline_Post
+// #define FN_Cvar_DirectSet_Post Cvar_DirectSet_Post
+// #define FN_ForceUnmodified_Post ForceUnmodified_Post
+// #define FN_GetPlayerStats_Post GetPlayerStats_Post
+// #define FN_AddServerCommand_Post AddServerCommand_Post
+// #define FN_Voice_GetClientListening_Post Voice_GetClientListening_Post
+// #define FN_Voice_SetClientListening_Post Voice_SetClientListening_Post
+// #define FN_GetPlayerAuthId_Post GetPlayerAuthId_Post
+
+// #define FN_OnFreeEntPrivateData OnFreeEntPrivateData
+// #define FN_GameShutdown GameShutdown
+// #define FN_ShouldCollide ShouldCollide
+
+// #define FN_OnFreeEntPrivateData_Post OnFreeEntPrivateData_Post
+// #define FN_GameShutdown_Post GameShutdown_Post
+// #define FN_ShouldCollide_Post ShouldCollide_Post
+
+
+#endif // USE_METAMOD
+
+#endif // __MODULECONFIG_H__
+
diff --git a/dlls/arrayx/osdefs.h b/dlls/arrayx/osdefs.h
new file mode 100644
index 00000000..60d61e68
--- /dev/null
+++ b/dlls/arrayx/osdefs.h
@@ -0,0 +1,60 @@
+/* __MSDOS__ set when compiling for DOS (not Windows)
+ * _Windows set when compiling for any version of Microsoft Windows
+ * __WIN32__ set when compiling for Windows95 or WindowsNT (32 bit mode)
+ * __32BIT__ set when compiling in 32-bit "flat" mode (DOS or Windows)
+ *
+ * Copyright 1998-2002, ITB CompuPhase, The Netherlands.
+ * info@compuphase.com.
+ */
+
+#ifndef _OSDEFS_H
+#define _OSDEFS_H
+
+/* Every compiler uses different "default" macros to indicate the mode
+ * it is in. Throughout the source, we use the Borland C++ macros, so
+ * the macros of Watcom C/C++ and Microsoft Visual C/C++ are mapped to
+ * those of Borland C++.
+ */
+#if defined(__WATCOMC__)
+# if defined(__WINDOWS__) || defined(__NT__)
+# define _Windows 1
+# endif
+# ifdef __386__
+# define __32BIT__ 1
+# endif
+# if defined(_Windows) && defined(__32BIT__)
+# define __WIN32__ 1
+# endif
+#elif defined(_MSC_VER)
+# if defined(_WINDOWS) || defined(_WIN32)
+# define _Windows 1
+# endif
+# ifdef _WIN32
+# define __WIN32__ 1
+# define __32BIT__ 1
+# endif
+#endif
+
+#if defined __linux__
+ #include
+#endif
+
+/* Linux NOW has these */
+#if !defined BIG_ENDIAN
+ #define BIG_ENDIAN 4321
+#endif
+#if !defined LITTLE_ENDIAN
+ #define LITTLE_ENDIAN 1234
+#endif
+
+/* educated guess, BYTE_ORDER is undefined, i386 is common => little endian */
+#if !defined BYTE_ORDER
+ #if defined UCLINUX
+ #define BYTE_ORDER BIG_ENDIAN
+ #else
+ #define BYTE_ORDER LITTLE_ENDIAN
+ #endif
+#endif
+
+#endif /* _OSDEFS_H */
+
|