From 66d7d39beedde5a91ed35745f0e61ccae50e7a4d Mon Sep 17 00:00:00 2001 From: Steve Dudenhoeffer Date: Fri, 4 May 2007 12:51:13 +0000 Subject: [PATCH] First commit of the rewrite Doesn't build on windows for some retarded reason --- dlls/hamsandwich/CString.h | 413 +++ dlls/hamsandwich/CVector.h | 491 ++++ dlls/hamsandwich/Makefile | 101 + dlls/hamsandwich/NEW_Util.h | 88 + dlls/hamsandwich/Trampolines.h | 706 +++++ dlls/hamsandwich/amxx_api.cpp | 31 + dlls/hamsandwich/call_funcs.cpp | 502 ++++ dlls/hamsandwich/call_funcs.h | 54 + dlls/hamsandwich/celltotype.h | 54 + dlls/hamsandwich/config/hamdata.ini | 690 +++++ dlls/hamsandwich/config_parser.cpp | 369 +++ dlls/hamsandwich/ecall_funcs.cpp | 479 ++++ dlls/hamsandwich/ecall_funcs.h | 54 + dlls/hamsandwich/forward.h | 40 + dlls/hamsandwich/ham_const.h | 113 + dlls/hamsandwich/ham_utils.h | 124 + dlls/hamsandwich/hook.h | 80 + dlls/hamsandwich/hook_callbacks.cpp | 563 ++++ dlls/hamsandwich/hook_callbacks.h | 67 + dlls/hamsandwich/hook_create.cpp | 125 + dlls/hamsandwich/hook_create.h | 54 + dlls/hamsandwich/hook_native.cpp | 267 ++ dlls/hamsandwich/hooklist.h | 19 + dlls/hamsandwich/include/hamsandwich.inc | 179 ++ dlls/hamsandwich/msvc7/fakemeta.sln | 21 + dlls/hamsandwich/msvc7/fakemeta.vcproj | 245 ++ dlls/hamsandwich/msvc8/hamsandwich.sln | 20 + dlls/hamsandwich/msvc8/hamsandwich.vcproj | 305 ++ dlls/hamsandwich/offsets.h | 55 + dlls/hamsandwich/sdk/amxxmodule.cpp | 3119 +++++++++++++++++++++ dlls/hamsandwich/sdk/amxxmodule.h | 2454 ++++++++++++++++ dlls/hamsandwich/sdk/moduleconfig.h | 494 ++++ dlls/hamsandwich/srvcmd.cpp | 100 + dlls/hamsandwich/typetocell.h | 61 + 34 files changed, 12537 insertions(+) create mode 100644 dlls/hamsandwich/CString.h create mode 100644 dlls/hamsandwich/CVector.h create mode 100644 dlls/hamsandwich/Makefile create mode 100644 dlls/hamsandwich/NEW_Util.h create mode 100644 dlls/hamsandwich/Trampolines.h create mode 100644 dlls/hamsandwich/amxx_api.cpp create mode 100644 dlls/hamsandwich/call_funcs.cpp create mode 100644 dlls/hamsandwich/call_funcs.h create mode 100644 dlls/hamsandwich/celltotype.h create mode 100644 dlls/hamsandwich/config/hamdata.ini create mode 100644 dlls/hamsandwich/config_parser.cpp create mode 100644 dlls/hamsandwich/ecall_funcs.cpp create mode 100644 dlls/hamsandwich/ecall_funcs.h create mode 100644 dlls/hamsandwich/forward.h create mode 100644 dlls/hamsandwich/ham_const.h create mode 100644 dlls/hamsandwich/ham_utils.h create mode 100644 dlls/hamsandwich/hook.h create mode 100644 dlls/hamsandwich/hook_callbacks.cpp create mode 100644 dlls/hamsandwich/hook_callbacks.h create mode 100644 dlls/hamsandwich/hook_create.cpp create mode 100644 dlls/hamsandwich/hook_create.h create mode 100644 dlls/hamsandwich/hook_native.cpp create mode 100644 dlls/hamsandwich/hooklist.h create mode 100644 dlls/hamsandwich/include/hamsandwich.inc create mode 100644 dlls/hamsandwich/msvc7/fakemeta.sln create mode 100644 dlls/hamsandwich/msvc7/fakemeta.vcproj create mode 100644 dlls/hamsandwich/msvc8/hamsandwich.sln create mode 100644 dlls/hamsandwich/msvc8/hamsandwich.vcproj create mode 100644 dlls/hamsandwich/offsets.h create mode 100644 dlls/hamsandwich/sdk/amxxmodule.cpp create mode 100644 dlls/hamsandwich/sdk/amxxmodule.h create mode 100644 dlls/hamsandwich/sdk/moduleconfig.h create mode 100644 dlls/hamsandwich/srvcmd.cpp create mode 100644 dlls/hamsandwich/typetocell.h diff --git a/dlls/hamsandwich/CString.h b/dlls/hamsandwich/CString.h new file mode 100644 index 00000000..1c77cfac --- /dev/null +++ b/dlls/hamsandwich/CString.h @@ -0,0 +1,413 @@ +/* AMX Mod X +* +* by the AMX Mod X Development Team +* originally developed by OLO +* +* +* 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. +*/ + +#ifndef _INCLUDE_CSTRING_H +#define _INCLUDE_CSTRING_H + +#include +#include + +//by David "BAILOPAN" Anderson +class String +{ +public: + String() + { + v = NULL; + a_size = 0; + //assign(""); + } + + ~String() + { + if (v) + delete [] v; + } + + String(const char *src) + { + v = NULL; + a_size = 0; + assign(src); + } + + const char * _fread(FILE *fp) + { + Grow(512, false); + char *ret = fgets(v, 511, fp); + return ret; + } + + String(const String &src) + { + v = NULL; + a_size = 0; + assign(src.c_str()); + } + + const char *c_str() { return v?v:""; } + + const char *c_str() const { return v?v:""; } + + void append(const char *t) + { + Grow(size() + strlen(t) + 1); + strcat(v, t); + } + + void append(const char c) + { + size_t len = size(); + Grow(len + 2); + v[len] = c; + v[len + 1] = '\0'; + } + + void append(String &d) + { + append(d.c_str()); + } + + void assign(const String &src) + { + assign(src.c_str()); + } + + void assign(const char *d) + { + if (!d) + { + clear(); + } else { + size_t len = strlen(d); + Grow(len + 1, false); + memcpy(v, d, len); + v[len] = '\0'; + } + } + + void clear() + { + if (v) + v[0] = '\0'; + } + + int compare (const char *d) const + { + if (!v) + return strcmp("", d); + else + return strcmp(v, d); + } + + //Added this for amxx inclusion + bool empty() + { + if (!v) + return true; + + if (v[0] == '\0') + return true; + + return false; + } + + size_t size() + { + if (v) + return strlen(v); + else + return 0; + } + + int find(const char c, int index = 0) + { + int len = static_cast(size()); + if (len < 1) + return npos; + if (index >= len || index < 0) + return npos; + int i = 0; + for (i=index; i=0; i--) + { + if (!is_space(v[i]) + || (is_space(v[i]) && i==0)) + { + erase(i+1, j); + break; + } + j++; + } + } + + if (len == 1) + { + if (is_space(v[0])) + { + clear(); + return; + } + } + } + + void erase(unsigned int start, int num = npos) + { + if (!v) + return; + unsigned int i = 0; + size_t len = size(); + //check for bounds + if (num == npos || start+num > len-start) + num = len - start; + //do the erasing + bool copyflag = false; + for (i=0; i=start && i= len || !v) + return ns; + + if (num == npos) + { + num = len - index; + } else if (index+num >= len) { + num = len - index; + } + + unsigned int i = 0; + unsigned int nslen = num + 2; + + ns.Grow(nslen); + + for (i=index; i= 65 && v[i] <= 90) + v[i] &= ~(1<<5); + } + } + + String & operator = (const String &src) + { + assign(src); + return *this; + } + + String & operator = (const char *src) + { + assign(src); + return *this; + + } + + char operator [] (unsigned int index) + { + if (index > size() || !v) + { + return -1; + } else { + return v[index]; + } + } + + int at(int a) + { + if (a < 0 || a >= (int)size() || !v) + return -1; + + return v[a]; + } + + bool at(int at, char c) + { + if (at < 0 || at >= (int)size() || !v) + return false; + + v[at] = c; + + return true; + } + +private: + void Grow(unsigned int d, bool copy=true) + { + if (d <= a_size) + return; + char *n = new char[d + 1]; + if (copy && v) + strcpy(n, v); + if (v) + delete [] v; + else + strcpy(n, ""); + v = n; + a_size = d + 1; + } + + char *v; + unsigned int a_size; +public: + static const int npos = -1; +}; + +#endif //_INCLUDE_CSTRING_H diff --git a/dlls/hamsandwich/CVector.h b/dlls/hamsandwich/CVector.h new file mode 100644 index 00000000..d0fef2be --- /dev/null +++ b/dlls/hamsandwich/CVector.h @@ -0,0 +1,491 @@ +/* AMX Mod X +* +* by the AMX Mod X Development Team +* originally developed by OLO +* +* +* 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. +*/ + +#ifndef __CVECTOR_H__ +#define __CVECTOR_H__ + +#include + +// Vector +template class CVector +{ + bool Grow() + { + // automatic grow + size_t newSize = m_Size * 2; + if (newSize == 0) + newSize = 8; // a good init value + T *newData = new T[newSize]; + if (!newData) + return false; + if (m_Data) + { + for (size_t i=0; i= m_Size) + return Grow(); + else + return true; + } + + bool ChangeSize(size_t size) + { + // change size + if (size == m_Size) + return true; + + if (!size) + { + if (m_Data) + { + delete [] m_Data; + m_Data = NULL; + m_Size = 0; + } + return true; + } + + T *newData = new T[size]; + if (!newData) + return false; + if (m_Data) + { + size_t end = (m_CurrentUsedSize < size) ? (m_CurrentUsedSize) : size; + for (size_t i=0; i m_Size) + m_CurrentUsedSize = m_Size; + + return true; + } + + void FreeMemIfPossible() + { + if (!m_Data) + return; + + if (!m_CurrentUsedSize) + { + ChangeSize(0); + return; + } + + size_t newSize = m_Size; + while (m_CurrentUsedSize <= newSize / 2) + newSize /= 2; + + if (newSize != m_Size) + ChangeSize(newSize); + } +protected: + T *m_Data; + size_t m_Size; + size_t m_CurrentUsedSize; +public: + class iterator + { + protected: + T *m_Ptr; + public: + // constructors / destructors + iterator() + { + m_Ptr = NULL; + } + + iterator(T * ptr) + { + m_Ptr = ptr; + } + + // member functions + T * base() + { + return m_Ptr; + } + + const T * base() const + { + return m_Ptr; + } + + // operators + T & operator*() + { + return *m_Ptr; + } + + T * operator->() + { + return m_Ptr; + } + + iterator & operator++() // preincrement + { + ++m_Ptr; + return (*this); + } + + iterator operator++(int) // postincrement + { + iterator tmp = *this; + ++m_Ptr; + return tmp; + } + + iterator & operator--() // predecrement + { + --m_Ptr; + return (*this); + } + + iterator operator--(int) // postdecrememnt + { + iterator tmp = *this; + --m_Ptr; + return tmp; + } + + bool operator==(T * right) const + { + return (m_Ptr == right); + } + + bool operator==(const iterator & right) const + { + return (m_Ptr == right.m_Ptr); + } + + bool operator!=(T * right) const + { + return (m_Ptr != right); + } + + bool operator!=(const iterator & right) const + { + return (m_Ptr != right.m_Ptr); + } + + iterator & operator+=(size_t offset) + { + m_Ptr += offset; + return (*this); + } + + iterator & operator-=(size_t offset) + { + m_Ptr -= offset; + return (*this); + } + + iterator operator+(size_t offset) const + { + iterator tmp(*this); + tmp.m_Ptr += offset; + return tmp; + } + + iterator operator-(size_t offset) const + { + iterator tmp(*this); + tmp.m_Ptr -= offset; + return tmp; + } + + T & operator[](size_t offset) + { + return (*(*this + offset)); + } + + const T & operator[](size_t offset) const + { + return (*(*this + offset)); + } + + bool operator<(const iterator & right) const + { + return m_Ptr < right.m_Ptr; + } + + bool operator>(const iterator & right) const + { + return m_Ptr > right.m_Ptr; + } + + bool operator<=(const iterator & right) const + { + return m_Ptr <= right.m_Ptr; + } + + bool operator>=(const iterator & right) const + { + return m_Ptr >= right.m_Ptr; + } + + size_t operator-(const iterator & right) const + { + return m_Ptr - right.m_Ptr; + } + }; + + // constructors / destructors + CVector() + { + m_Size = 0; + m_CurrentUsedSize = 0; + m_Data = NULL; + } + + CVector(const CVector & other) + { + // copy data + m_Data = new T [other.m_CurrentUsedSize]; + m_Size = other.m_CurrentUsedSize; + m_CurrentUsedSize = other.m_CurrentUsedSize; + for (size_t i=0; i() + { + clear(); + } + + // interface + size_t size() const + { + return m_CurrentUsedSize; + } + + size_t capacity() const + { + return m_Size; + } + + iterator begin() const + { + return iterator(m_Data); + } + + iterator end() const + { + return iterator(m_Data + m_CurrentUsedSize); + } + + iterator iterAt(size_t pos) + { + if (pos > m_CurrentUsedSize) + assert(0); + return iterator(m_Data + pos); + } + + bool reserve(size_t newSize) + { + if (newSize > m_Size) + return ChangeSize(newSize); + return true; + } + + bool push_back(const T & elem) + { + ++m_CurrentUsedSize; + if (!GrowIfNeeded()) + { + --m_CurrentUsedSize; + return false; + } + + m_Data[m_CurrentUsedSize - 1] = elem; + return true; + } + + void pop_back() + { + --m_CurrentUsedSize; + if (m_CurrentUsedSize < 0) + m_CurrentUsedSize = 0; + + FreeMemIfPossible(); + } + + bool resize(size_t newSize) + { + if (!ChangeSize(newSize)) + return false; + m_CurrentUsedSize = newSize; + return true; + } + + bool empty() const + { + return (m_CurrentUsedSize == 0); + } + + T & at(size_t pos) + { + if (pos > m_CurrentUsedSize) + { + assert(0); + } + return m_Data[pos]; + } + + const T & at(size_t pos) const + { + if (pos > m_CurrentUsedSize) + { + assert(0); + } + return m_Data[pos]; + } + + T & operator[](size_t pos) + { + return at(pos); + } + + const T & operator[](size_t pos) const + { + return at(pos); + } + + T & front() + { + if (m_CurrentUsedSize < 1) + { + assert(0); + } + return m_Data[0]; + } + + const T & front() const + { + if (m_CurrentUsedSize < 1) + { + assert(0); + } + return m_Data[0]; + } + + T & back() + { + if (m_CurrentUsedSize < 1) + { + assert(0); + } + return m_Data[m_CurrentUsedSize - 1]; + } + + const T & back() const + { + if (m_CurrentUsedSize < 1) + { + assert(0); + } + return m_Data[m_CurrentUsedSize - 1]; + } + + iterator insert(iterator where, const T & value) + { + // validate iter + if (where < m_Data || where > (m_Data + m_CurrentUsedSize)) + return iterator(0); + + size_t ofs = where - begin(); + + ++m_CurrentUsedSize; + if (!GrowIfNeeded()) + { + --m_CurrentUsedSize; + return false; + } + + where = begin() + ofs; + + // Move subsequent entries + for (T *ptr = m_Data + m_CurrentUsedSize - 2; ptr >= where.base(); --ptr) + *(ptr + 1) = *ptr; + + *where.base() = value; + + return where; + } + + iterator erase(iterator where) + { + // validate iter + if (where < m_Data || where >= (m_Data + m_CurrentUsedSize)) + return iterator(0); + + size_t ofs = where - begin(); + + if (m_CurrentUsedSize > 1) + { + // move + T *theend = m_Data + m_CurrentUsedSize; + for (T *ptr = where.base() + 1; ptr < theend; ++ptr) + *(ptr - 1) = *ptr; + } + + --m_CurrentUsedSize; + + FreeMemIfPossible(); + + return begin() + ofs; + } + + void clear() + { + m_Size = 0; + m_CurrentUsedSize = 0; + if (m_Data) + { + delete [] m_Data; + m_Data = NULL; + } + } +}; + +#endif // __CVECTOR_H__ + diff --git a/dlls/hamsandwich/Makefile b/dlls/hamsandwich/Makefile new file mode 100644 index 00000000..29501620 --- /dev/null +++ b/dlls/hamsandwich/Makefile @@ -0,0 +1,101 @@ +#(C)2004-2005 AMX Mod X Development Team +# Makefile written by David "BAILOPAN" Anderson + +HLSDK = ../../../hlsdk +MM_ROOT = ../../metamod/metamod + +### EDIT BELOW FOR OTHER PROJECTS ### + + +CRAZY_OPT_FLAGS = -DCRAZY_OPTS -O3 -funroll-loops -ffast-math -s -pipe -fomit-frame-pointer -fno-strict-aliasing -DNDEBUG -fmerge-all-constants -fmodulo-sched -fgcse-sm -fgcse-las -fgcse-after-reload -floop-optimize2 -funsafe-loop-optimizations -ftree-loop-linear -ftree-loop-im -ftree-loop-ivcanon -fivopts -ftree-vectorize -fvariable-expansion-in-unroller -funsafe-math-optimizations -ffinite-math-only -fpeel-loops -funswitch-loops -fvisibility=hidden -fvisibility-inlines-hidden -fPIC -Wall -Wno-unknown-pragmas -Wno-deprecated -fno-exceptions -DHAVE_STDINT_H -static-libgcc -fno-rtti -Wpointer-arith -Wcast-qual -Wcast-align -Wconversion -Wsign-compare -Wmissing-noreturn -Winline -Wlong-long -Wunsafe-loop-optimizations -Wctor-dtor-privacy -Wno-non-virtual-dtor -Wreorder -Woverloaded-virtual -Wsign-promo -Wsynth -shared + +CRAZY_LINK_FLAGS = -fwhole-program +#-fwhole-program -combine + +SANE_OPT_FLAGS = -O3 -funroll-loops -s -pipe -fomit-frame-pointer -fno-strict-aliasing -DNDEBUG + +OPT_FLAGS = + +DEBUG_FLAGS = -g -ggdb3 +CPP = gcc-4.1 +#CPP = gcc-2.95 +NAME = hamsandwich + +BIN_SUFFIX = amxx_i386.so + +OBJECTS = sdk/amxxmodule.cpp amxx_api.cpp config_parser.cpp \ +hook_callbacks.cpp hook_native.cpp srvcmd.cpp \ +call_funcs.cpp ecall_funcs.cpp hook_create.cpp + + +LINK = + +INCLUDE = -I. -I$(HLSDK) -I$(HLSDK)/dlls -I$(HLSDK)/engine -I$(HLSDK)/game_shared -I$(HLSDK)/game_shared \ + -I$(MM_ROOT) -I$(HLSDK)/common -I$(HLSDK)/pm_shared -I./tableentries + +GCC_VERSION := $(shell $(CPP) -dumpversion >&1 | cut -b1) + +ifeq "$(DEBUG)" "true" + BIN_DIR = Debug + CFLAGS = $(DEBUG_FLAGS) +else + ifeq "$(CRAZY)" "true" + BIN_DIR = Optimized + OPT_FLAGS = $(CRAZY_OPT_FLAGS) + LINK = $(CRAZY_LINK_FLAGS) + else + BIN_DIR = Release + OPT_FLAGS = $(SANE_OPT_FLAGS) + endif + ifeq "$(GCC_VERSION)" "4" + OPT_FLAGS += -fvisibility=hidden -fvisibility-inlines-hidden + endif + CFLAGS = $(OPT_FLAGS) +endif + +CFLAGS += -fPIC -Wall -Wno-non-virtual-dtor -fno-exceptions -DHAVE_STDINT_H -fno-rtti + +BINARY = $(NAME)_$(BIN_SUFFIX) +CFLAGS += -DPAWN_CELL_SIZE=32 -DJIT -DASM32 +OPT_FLAGS += -march=i586 + +OBJ_LINUX := $(OBJECTS:%.cpp=$(BIN_DIR)/%.o) + +$(BIN_DIR)/%.o: %.cpp + $(CPP) $(INCLUDE) $(CFLAGS) -o $@ -c $< + +all: + mkdir -p $(BIN_DIR) + mkdir -p $(BIN_DIR)/sdk + mkdir -p $(BIN_DIR)/natives + mkdir -p $(BIN_DIR)/tableentries + $(MAKE) hamsandwich + +hamsandwich: $(OBJ_LINUX) + $(CPP) $(INCLUDE) $(CFLAGS) $(OBJ_LINUX) $(LINK) -shared -ldl -lm -o$(BIN_DIR)/$(BINARY) + +debug: + $(MAKE) all DEBUG=true + +default: all + +crazy: + $(MAKE) all CRAZY=true + +clean: + rm -rf Release/*.o + rm -rf Release/sdk/*.o + rm -rf Release/natives/*.o + rm -rf Release/tableentries/*.o + rm -rf Release/$(NAME)_$(BIN_SUFFIX) + rm -rf Debug/*.o + rm -rf Debug/sdk/*.o + rm -rf Debug/natives/*.o + rm -rf Debug/tableentries/*.o + rm -rf Debug/$(NAME)_$(BIN_SUFFIX) + rm -rf Optimized/*.o + rm -rf Optimized/sdk/*.o + rm -rf Optimized/natives/*.o + rm -rf Optimized/tableentries/*.o + rm -rf Optimized/$(NAME)_$(BIN_SUFFIX) + diff --git a/dlls/hamsandwich/NEW_Util.h b/dlls/hamsandwich/NEW_Util.h new file mode 100644 index 00000000..c2796a92 --- /dev/null +++ b/dlls/hamsandwich/NEW_Util.h @@ -0,0 +1,88 @@ +/* Ham Sandwich + * + * by sawce + * + * + * 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. + */ + +/* Inlined replacements for INDEXENT/ENTINDEX + * It only really removes the overhead of the push/jump + * but since INDEXENT/ENTINDEX are used a lot with amxx + * it might be beneficial to include. + * NOTE: Bad stuff will happen if you call these before + * NEW_Initialize() + * NOTE: No bounds checking is done because natives + * should use their own bounds checking! + */ + +#ifndef NEW_UTIL_H +#define NEW_UTIL_H + + +extern edict_t *NEW_FirstEdict; +extern bool NEW_Initialized; + +/** + * This is called on the first Spawn() ever hooked. This would be worldspawn (index 0) + */ +inline void NEW_Initialize(edict_t *Entity) +{ + NEW_FirstEdict=Entity; + NEW_Initialized=true; +} + + +/** + * Converts an integer index into an edict pointer + */ +inline edict_t *INDEXENT_NEW(const int Index) +{ + return (edict_t *)(NEW_FirstEdict + Index); +}; + +/** + * Converts an edict pointer into an integer index + */ +inline int ENTINDEX_NEW(const edict_t *Ent) +{ + return (int)(Ent - NEW_FirstEdict); +}; + +// Inlined replacement of MF_GetAmxAddr + + +inline REAL amx_ctof2(cell x) +{ + return *(REAL*)&x; +} +inline cell amx_ftoc2(REAL x) +{ + return *(cell*)&x; +} + + +#endif // NEW_UTIL_H + diff --git a/dlls/hamsandwich/Trampolines.h b/dlls/hamsandwich/Trampolines.h new file mode 100644 index 00000000..89cf1b06 --- /dev/null +++ b/dlls/hamsandwich/Trampolines.h @@ -0,0 +1,706 @@ +/* Trampolines + * + * + * 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. + */ + + +#ifndef TRAMPOLINES_H +#define TRAMPOLINES_H + +#ifndef NDEBUG +#define TPRINT(msg) printf msg +#else +#define TPRINT(msg) /* nothing */ +#endif + +#if defined _WIN32 +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif // WIN32_LEAN_AND_MEAN +#if _MSC_VER >= 1400 +#ifdef offsetof +#undef offsetof +#endif // offsetof +#endif // _MSC_VER >= 1400 +#include +#elif defined __linux__ +#include +#include +#endif +#include // size_t +#include // memcpy +#include // memalign +#include + + +namespace Trampolines +{ + + /** + * List of x86 bytecodes for creating + * basic trampolines at runtime. + * - + * These are defined here so that, should + * the need ever arise, this can be ported + * to other architectures fairly painlessly + */ + namespace Bytecode + { + /** + * Prologue for a void function + * Clobbers EBX and EAX + */ + const unsigned char codeVoidPrologue[] = { + 0x55, // push ebp + 0x89, 0xE5, // mov ebp, esp + 0x50, // push eax + }; + + /** + * Prologue for a function that returns + * Clobbers EBX, EAX too but not after call + */ + const unsigned char codeReturnPrologue[] = { + 0x55, // push ebp + 0x89, 0xE5, // mov ebp, esp + }; + const unsigned char codeThisReturnPrologue[] = { + 0x55, // push ebp + 0x89, 0xE5, // mov ebp, esp + }; + + + /** + * Takes a paramter from the trampoline's stack + * and pushes it onto the target's stack. + */ + const unsigned char codePushParam[] = { + 0xFF, 0x75, 0xFF // pushl [ebp+0xFF] + }; + + /** + * Offset of codePushParam to modify at runtime + * that contains the stack offset + */ + const unsigned int codePushParamReplace = 2; + + + /** + * Takes the "this" pointer from the trampoline and + * pushes it onto the target's stack. + */ + const unsigned char codePushThis[] = { + #if defined _WIN32 + 0x51 // push ecx + #elif defined __linux__ + 0xFF, 0x75, 0x04 // pushl [ebp+0x08h] + #endif + }; + +#if defined __linux__ + const int codePushThisReplace = 2; +#endif + + /** + * Pushes a raw number onto the target's stack + */ + const unsigned char codePushID[] = { + 0x68, 0xDE, 0xFA, 0xAD, 0xDE // push DEADFADEh + }; + + /** + * Offset of codePushID to modify at runtime + * to contain the number to push + */ + const unsigned int codePushIDReplace = 1; + + /** + * Call our procedure + */ + const unsigned char codeCall[] = { + 0xB8, 0xDE, 0xFA, 0xAD, 0xDE,// mov eax, DEADFADEh + 0xFF, 0xD0 // call eax + }; + + /** + * Offset of codeCall to modify at runtime + * to contain the pointer to the function + */ + const unsigned int codeCallReplace = 1; + + /** + * Adds to ESP, freeing up stack space + */ + const unsigned char codeFreeStack[] = { + 0x81, 0xC4, 0xFF, 0xFF, 0xFF, 0xFF// add esp REPLACEME + }; + + /** + * Offset of codeFreeStack to modify at runtime + * to contain how much data to free + */ + const unsigned int codeFreeStackReplace = 2; + + /** + * Epilogue of a simple return function + */ + const unsigned char codeReturnEpilogue[] = { + 0x5D, // pop ebp + 0xC3 // ret + }; + const unsigned char codeReturnEpilogueN[] = { + 0x5D, // pop ebp + 0xC2, 0xCD, 0xAB // retn 0xABCD + }; + const int codeReturnEpilogueNReplace = 2; + + + /** + * Epilogue of a void return function + */ + const unsigned char codeVoidEpilogue[] = { + 0x58, // pop eax + 0x5D, // pop ebp + 0xC3 // ret + }; + + const unsigned char codeVoidEpilogueN[] = { + 0x58, // pop eax + 0x5D, // pop ebp + 0xC2, 0xCD, 0xAB // retn 0xABCD + }; + const int codeVoidEpilogueNReplace = 3; + + + + const unsigned char codeBreakpoint[] = { + 0xCC // int 3 + }; + + } + + /** + * Our actual maker of the trampolines!!@$ + * I've no idea why I made this a class and not a namespace + * Oh well! + */ + + class TrampolineMaker + { + private: + unsigned char *m_buffer; // the actual buffer containing the code + int m_size; // size of the buffer + int m_mystack; // stack for the trampoline itself + int m_calledstack; // stack for the target function + int m_paramstart; + int m_thiscall; + int m_maxsize; + + /** + * Adds data to the buffer + * data must be pre-formatted before hand! + */ + void Append(const unsigned char *src, size_t size) + { + int orig=m_size; + m_size+=size; + + if (m_buffer==NULL) + { + m_maxsize=512; + m_buffer=(unsigned char *)malloc(m_maxsize); + } + else if (m_size > m_maxsize) + { + m_maxsize = m_size + 512; + m_buffer=(unsigned char *)realloc(m_buffer,m_maxsize); + } + + unsigned char *dat=m_buffer+orig; // point dat to the end of the prewritten + + while (origReturnPrologue(); + m_thiscall=1; + }; + + /** + * Adds the void prologue pushes registers, prepares the stack + */ + void VoidPrologue() + { + Append(&::Trampolines::Bytecode::codeVoidPrologue[0],sizeof(::Trampolines::Bytecode::codeVoidPrologue)); + m_paramstart=0; + m_thiscall=0; + }; + + /** + * Flags this trampoline as a thiscall trampoline, and prepares the void prologue. + */ + void ThisVoidPrologue() + { + this->VoidPrologue(); + m_thiscall=1; + }; + /** + * Epilogue for a returning function pops registers but does not free any more of the stack! + */ + void ReturnEpilogue() + { + Append(&::Trampolines::Bytecode::codeReturnEpilogue[0],sizeof(::Trampolines::Bytecode::codeReturnEpilogue)); + }; + + /** + * Epilogue that also frees it's estimated stack usage. Useful for stdcall/thiscall/fastcall. + */ + void ReturnEpilogueAndFree() + { + this->ReturnEpilogue(m_mystack); + }; + + /** + * Return epilogue. Pops registers, and frees given amount of data from the stack. + * + * @param howmuch How many bytes to free from the stack. + */ + void ReturnEpilogue(int howmuch) + { + + unsigned char code[sizeof(::Trampolines::Bytecode::codeReturnEpilogueN)]; + + memcpy(&code[0],&::Trampolines::Bytecode::codeReturnEpilogueN[0],sizeof(::Trampolines::Bytecode::codeReturnEpilogueN)); + + + unsigned char *c=&code[0]; + + union + { + int i; + unsigned char b[4]; + } bi; + + bi.i=howmuch; + + c+=::Trampolines::Bytecode::codeReturnEpilogueNReplace; + *c++=bi.b[0]; + *c++=bi.b[1]; + + Append(&code[0],sizeof(::Trampolines::Bytecode::codeReturnEpilogueN)); + //Append(&::Trampolines::Bytecode::codeReturnEpilogueN[0],sizeof(::Trampolines::Bytecode::codeReturnEpilogueN)); + }; + + /** + * Void epilogue, pops registers and frees the estimated stack usage of the trampoline. + */ + void VoidEpilogueAndFree() + { + this->VoidEpilogue(m_mystack); + }; + /** + * Void epilogue, pops registers, nothing else done with stack. + */ + void VoidEpilogue() + { + Append(&::Trampolines::Bytecode::codeVoidEpilogue[0],sizeof(::Trampolines::Bytecode::codeVoidEpilogue)); + }; + /** + * Void epilogue, pops registers, frees given amount of data off of the stack. + * + * @param howmuch How many bytes to free from the stack. + */ + void VoidEpilogue(int howmuch) + { + + unsigned char code[sizeof(::Trampolines::Bytecode::codeVoidEpilogueN)]; + + memcpy(&code[0],&::Trampolines::Bytecode::codeVoidEpilogueN[0],sizeof(::Trampolines::Bytecode::codeVoidEpilogueN)); + + + unsigned char *c=&code[0]; + + union + { + int i; + unsigned char b[4]; + } bi; + + bi.i=howmuch; + + c+=::Trampolines::Bytecode::codeVoidEpilogueNReplace; + *c++=bi.b[0]; + *c++=bi.b[1]; + + Append(&code[0],sizeof(::Trampolines::Bytecode::codeVoidEpilogueN)); + Append(&::Trampolines::Bytecode::codeVoidEpilogueN[0],sizeof(::Trampolines::Bytecode::codeVoidEpilogueN)); + }; + + /** + * Pushes the "this" pointer onto the callee stack. Pushes ECX for MSVC, and param0 on GCC. + */ + void PushThis() + { + + if (!m_thiscall) + { + return; + } + + unsigned char code[sizeof(::Trampolines::Bytecode::codePushThis)]; + + memcpy(&code[0],&::Trampolines::Bytecode::codePushThis[0],sizeof(::Trampolines::Bytecode::codePushThis)); + + +#if defined __linux__ + unsigned char *c=&code[0]; + + union + { + int i; + unsigned char b[4]; + } bi; + + bi.i=m_paramstart+8; + + c+=::Trampolines::Bytecode::codePushThisReplace; + *c++=bi.b[0]; +#endif + + Append(&code[0],sizeof(::Trampolines::Bytecode::codePushThis)); + +#if defined __linux__ + TPRINT(("mystack=%d+4\n",m_mystack)); + m_mystack+=4; +#endif + TPRINT(("calledstack=%d+4\n",m_calledstack)); + m_calledstack+=4; + }; + + /** + * Frees what is estimated as the stack usage of the trampoline. + */ + void FreeMyStack(void) + { + + TPRINT(("freeing mystack=%d+4\n",m_mystack)); + this->FreeStack(m_mystack); + }; + + /** + * Frees the estimated stack usage of the callee. + */ + void FreeTargetStack(void) + { + TPRINT(("freeing calledstack=%d+4\n",m_calledstack)); + this->FreeStack(m_calledstack); + }; + + + /** + * Frees the estimated stack usage of the callee and the trampoline. + */ + void FreeBothStacks(void) + { + TPRINT(("freeing mystack=%d+4\n",m_mystack)); + TPRINT(("freeing calledstack=%d+4\n",m_calledstack)); + this->FreeStack(m_calledstack + m_mystack); + }; + + /** + * Frees a given amount of bytes from the stack. + * + * @param howmuch How many bytes to free. + */ + void FreeStack(int howmuch) + { + unsigned char code[sizeof(::Trampolines::Bytecode::codeFreeStack)]; + + memcpy(&code[0],&::Trampolines::Bytecode::codeFreeStack[0],sizeof(::Trampolines::Bytecode::codeFreeStack)); + + unsigned char *c=&code[0]; + + union + { + int i; + unsigned char b[4]; + } bi; + + bi.i=howmuch; + + c+=::Trampolines::Bytecode::codeFreeStackReplace; + *c++=bi.b[0]; + *c++=bi.b[1]; + *c++=bi.b[2]; + *c++=bi.b[3]; + + Append(&code[0],sizeof(::Trampolines::Bytecode::codeFreeStack)); + + }; + + /** + * Pushes a raw number onto the callee stack. + * + * @param Number The number to push onto the callee stack. + */ + void PushNum(int Number) + { + unsigned char code[sizeof(::Trampolines::Bytecode::codePushID)]; + + memcpy(&code[0],&::Trampolines::Bytecode::codePushID[0],sizeof(::Trampolines::Bytecode::codePushID)); + + unsigned char *c=&code[0]; + + union + { + int i; + unsigned char b[4]; + } bi; + + bi.i=Number; + + c+=::Trampolines::Bytecode::codePushIDReplace; + *c++=bi.b[0]; + *c++=bi.b[1]; + *c++=bi.b[2]; + *c++=bi.b[3]; + + Append(&code[0],sizeof(::Trampolines::Bytecode::codePushID)); + + TPRINT(("calledstack=%d+4\n",m_calledstack)); + m_calledstack+=4; // increase auto detected stack size + + }; + + + /** + * Takes a parameter passed on the trampoline's stack and inserts it into the callee's stack. + * + * @param which The parameter number to push. 1-based. "thiscall" trampolines automatically compensate for the off-number on GCC. + */ + void PushParam(int which) + { +#if defined __linux__ + if (m_thiscall) + { + which++; + } +#endif + which=which*4; + which+=m_paramstart+4; + + unsigned char value=which; + + unsigned char code[sizeof(::Trampolines::Bytecode::codePushParam)]; + + memcpy(&code[0],&::Trampolines::Bytecode::codePushParam[0],sizeof(::Trampolines::Bytecode::codePushParam)); + + unsigned char *c=&code[0]; + + + c+=::Trampolines::Bytecode::codePushParamReplace; + + *c=value; + + Append(&code[0],sizeof(::Trampolines::Bytecode::codePushParam)); + + TPRINT(("calledstack=%d+4\n",m_calledstack)); + m_calledstack+=4; // increase auto detected stack size + TPRINT(("mystack=%d+4\n",m_mystack)); + m_mystack+=4; + + }; + + /** + * Insert a function to call into the trampoline. + * + * @param ptr The function to call, cast to void*. + */ + void Call(void *ptr) + { + unsigned char code[sizeof(::Trampolines::Bytecode::codeCall)]; + + memcpy(&code[0],&::Trampolines::Bytecode::codeCall[0],sizeof(::Trampolines::Bytecode::codeCall)); + + unsigned char *c=&code[0]; + + union + { + void *p; + unsigned char b[4]; + } bp; + + bp.p=ptr; + + c+=::Trampolines::Bytecode::codeCallReplace; + + *c++=bp.b[0]; + *c++=bp.b[1]; + *c++=bp.b[2]; + *c++=bp.b[3]; + Append(&code[0],sizeof(::Trampolines::Bytecode::codeCall)); + + + }; + + /** + * Finalizes the trampoline. Do not try to modify it after this. + * + * @param size A pointer to retrieve the size of the trampoline. Ignored if set to NULL. + * @return The trampoline pointer, cast to void*. + */ + void *Finish(int *size) + { + //void *ret=(void *)m_buffer; + + if (size) + { + *size=m_size; + } + + // Reallocate with proper flags +#if defined _WIN32 + void *ret=VirtualAlloc(NULL, m_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE); +#elif defined __linux__ + void *ret=memalign(sysconf(_SC_PAGESIZE), m_size); + mprotect(ret,m_size,PROT_READ|PROT_WRITE|PROT_EXEC); +#endif + memcpy(ret, m_buffer, m_size); + + + m_size=0; + + free(m_buffer); + + m_buffer=NULL; // so we don't accidentally rewrite! + m_mystack=0; + m_calledstack=0; + m_maxsize=512; + + return ret; + }; + }; +}; + + +/** + * Utility to make a generic trampoline. + */ +inline void *CreateGenericTrampoline(bool thiscall, bool voidcall, int paramcount, void *extraptr, void *callee) +{ + Trampolines::TrampolineMaker tramp; + + if (voidcall) + { + if (thiscall) + { + tramp.ThisVoidPrologue(); + } + else + { + tramp.VoidPrologue(); + } + } + else + { + if (thiscall) + { + tramp.ThisReturnPrologue(); + } + else + { + tramp.ReturnPrologue(); + } + } + + while (paramcount) + { + tramp.PushParam(paramcount--); + } + if (thiscall) + { + tramp.PushThis(); + } + tramp.PushNum(reinterpret_cast(extraptr)); + tramp.Call(callee); + tramp.FreeTargetStack(); + if (voidcall) + { +#if defined _WIN32 + tramp.VoidEpilogueAndFree(); +#elif defined __linux__ + tramp.VoidEpilogue(); +#endif + } + else + { +#if defined _WIN32 + tramp.ReturnEpilogueAndFree(); +#elif defined __linux__ + tramp.ReturnEpilogue(); +#endif + } + return tramp.Finish(NULL); + +}; + + +#endif // TRAMPOLINEMANAGER_H diff --git a/dlls/hamsandwich/amxx_api.cpp b/dlls/hamsandwich/amxx_api.cpp new file mode 100644 index 00000000..84e78b4a --- /dev/null +++ b/dlls/hamsandwich/amxx_api.cpp @@ -0,0 +1,31 @@ +#include +#include "sdk/amxxmodule.h" +#include "NEW_Util.h" + +edict_t *NEW_FirstEdict; +bool NEW_Initialized; + + +extern AMX_NATIVE_INFO RegisterNatives[]; + +int ReadConfig(void); + +void OnAmxxAttach(void) +{ + printf("LOLOL"); + if (ReadConfig() > 0) + { + MF_AddNatives(RegisterNatives); + } +} + +void HamCommand(void); + +void OnPluginsLoaded(void) +{ + NEW_Initialize(INDEXENT(0)); +} +void OnMetaAttach(void) +{ + REG_SVR_COMMAND("ham", HamCommand); +} diff --git a/dlls/hamsandwich/call_funcs.cpp b/dlls/hamsandwich/call_funcs.cpp new file mode 100644 index 00000000..db434af4 --- /dev/null +++ b/dlls/hamsandwich/call_funcs.cpp @@ -0,0 +1,502 @@ +#include "sdk/amxxmodule.h" + +#include "offsets.h" +#include "ham_utils.h" +#include "hooklist.h" + +#include "CVector.h" +#include "forward.h" +#include "hook.h" + +#ifdef _WIN32 +#define LOL_CDECL __cdecl +#else +#define LOL_CDECL +#endif + + +extern CVector hooks[HAM_LAST_ENTRY_DONT_USE_ME_LOL]; + +void FailPlugin(AMX *amx, int id, int err, const char *reason); + +inline void *GetFunction(void *pthis, int id) +{ + void **vtbl=GetVTable(pthis, Offsets.GetBase()); + + int **ivtbl=(int **)vtbl; + void *func=ivtbl[hooklist[id].vtid]; + + // Iterate through the hooks for the id, see if the function is found + CVector::iterator end=hooks[id].end(); + + for (CVector::iterator i=hooks[id].begin(); + i!=end; + ++i) + { + // If the function points to a trampoline, then return the original + // function. + if (func==(*i)->tramp) + { + return (*i)->func; + } + } + + // this is an original function + return func; +} + +#define SETUP(NUMARGS) \ + if (((NUMARGS + 2) * sizeof(cell)) > (unsigned)params[0]) \ + { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Bad arg count. Expected %d, got %d.", NUMARGS + 2, params[0] / sizeof(cell)); \ + return 0; \ + } \ + int func=params[1]; \ + int id=params[2]; \ + CHECK_FUNCTION(func); \ + CHECK_ENTITY(id); \ + void *pv=IndexToPrivate(id); + + +cell LOL_CDECL Call_Void_Void(AMX *amx, cell *params) +{ + SETUP(0); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv); +#endif + return 1; +} + +cell LOL_CDECL Call_Int_Void(AMX *amx, cell *params) +{ + SETUP(0); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv); +#endif +} + +cell LOL_CDECL Call_Void_Entvar(AMX *amx, cell *params) +{ + SETUP(1); + + int id3=*MF_GetAmxAddr(amx, params[3]); + + CHECK_ENTITY(id3); + + entvars_t *ev1=&(INDEXENT_NEW(id3)->v); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, ev1); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, ev1); +#endif + return 1; +} + + +cell LOL_CDECL Call_Void_Cbase(AMX *amx, cell *params) +{ + SETUP(1); + + int id3=*MF_GetAmxAddr(amx, params[3]); + + CHECK_ENTITY(id3); + + void *pv1=(INDEXENT_NEW(id3)->pvPrivateData); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, pv1); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, pv1); +#endif + return 1; +} + +cell LOL_CDECL Call_Int_Float_Int(AMX *amx, cell *params) +{ + SETUP(2); + + float f3=amx_ftoc2(*MF_GetAmxAddr(amx, params[3])); + int i4=*MF_GetAmxAddr(amx, params[4]); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, f3, i4); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, f3, i4); +#endif +} + + +cell LOL_CDECL Call_Void_Entvar_Int(AMX *amx, cell *params) +{ + SETUP(2); + + int id3=*MF_GetAmxAddr(amx, params[3]); + int i4=*MF_GetAmxAddr(amx, params[4]); + + CHECK_ENTITY(id3); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3, i4); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, ev3, i4); +#endif + return 1; +} + + +cell LOL_CDECL Call_Int_Cbase(AMX *amx, cell *params) +{ + SETUP(1); + + int id3=*MF_GetAmxAddr(amx, params[3]); + + CHECK_ENTITY(id3); + + void *pv1=(INDEXENT_NEW(id3)->pvPrivateData); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, pv1); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, pv1); +#endif +} + +cell LOL_CDECL Call_Void_Int_Int(AMX *amx, cell *params) +{ + SETUP(2); + + int i3=*MF_GetAmxAddr(amx, params[3]); + int i4=*MF_GetAmxAddr(amx, params[4]); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, i3, i4); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, i3, i4); +#endif + return 1; +} + +cell LOL_CDECL Call_Int_Int_Str_Int(AMX *amx, cell *params) +{ + + SETUP(3); + + int i3=*MF_GetAmxAddr(amx, params[3]); + char *sz4=MF_GetAmxString(amx, params[4], 0, NULL); + int i5=*MF_GetAmxAddr(amx, params[5]); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, i3, sz4, i5); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, i3, sz4, i5); +#endif +} + +cell LOL_CDECL Call_Int_Int(AMX *amx, cell *params) +{ + SETUP(1); + + int i3=*MF_GetAmxAddr(amx, params[3]); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, i3); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, i3); +#endif +} + +cell LOL_CDECL Call_Int_Entvar(AMX *amx, cell *params) +{ + SETUP(1); + + int id3=*MF_GetAmxAddr(amx, params[3]); + + CHECK_ENTITY(id3); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, ev3); +#endif +} + +cell LOL_CDECL Call_Int_Entvar_Entvar_Float_Int(AMX *amx, cell *params) +{ + SETUP(4); + + int id3=*MF_GetAmxAddr(amx, params[3]); + int id4=*MF_GetAmxAddr(amx, params[4]); + float f5=amx_ctof2(*MF_GetAmxAddr(amx, params[5])); + int i6=*MF_GetAmxAddr(amx, params[6]); + + CHECK_ENTITY(id3); + CHECK_ENTITY(id4); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); + entvars_t *ev4=&(INDEXENT_NEW(id4)->v); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3, ev4, f5, i6); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, ev3, ev4, f5, i6); +#endif +} + +cell LOL_CDECL Call_Void_Int(AMX *amx, cell *params) +{ + SETUP(1); + + int i3=*MF_GetAmxAddr(amx, params[3]); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, i3); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, i3); +#endif + + return 1; +} + +cell LOL_CDECL Call_Void_Cbase_Cbase_Int_Float(AMX *amx, cell *params) +{ + SETUP(4); + + int id3=*MF_GetAmxAddr(amx, params[3]); + int id4=*MF_GetAmxAddr(amx, params[4]); + int i5=*MF_GetAmxAddr(amx, params[5]); + float f6=amx_ctof(*MF_GetAmxAddr(amx, params[6])); + + CHECK_ENTITY(id3); + CHECK_ENTITY(id4); + + void *p3=IndexToPrivate(id3); + void *p4=IndexToPrivate(id4); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, p3, p4, i5, f6); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, p3, p4, i5, f6); +#endif + + return 1; +} + +cell LOL_CDECL Call_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, cell *params) +{ + SETUP(5); + + int id3=*MF_GetAmxAddr(amx, params[3]); + float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4])); + Vector v5; + TraceResult *tr6=reinterpret_cast(*MF_GetAmxAddr(amx, params[6])); + int i7=*MF_GetAmxAddr(amx, params[7]); + + float *fl5=(float *)MF_GetAmxAddr(amx, params[5]); + v5.x=fl5[0]; + v5.y=fl5[1]; + v5.z=fl5[2]; + + if (tr6==NULL) + { + MF_LogError(amx, AMX_ERR_NATIVE, "Null traceresult provided."); + + return 0; + } + + CHECK_ENTITY(id3); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3, f4, v5, tr6, i7); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, ev3, f4, v5, tr6, i7); +#endif + + return 1; +} + +cell LOL_CDECL Call_Void_Float_Vector_TraceResult_Int(AMX *amx, cell *params) +{ + SETUP(4); + + float f3=amx_ctof2(*MF_GetAmxAddr(amx, params[3])); + Vector v4; + TraceResult *tr5=reinterpret_cast(*MF_GetAmxAddr(amx, params[5])); + int i6=*MF_GetAmxAddr(amx, params[6]); + + float *fl4=(float *)MF_GetAmxAddr(amx, params[4]); + v4.x=fl4[0]; + v4.y=fl4[1]; + v4.z=fl4[2]; + + if (tr5==NULL) + { + MF_LogError(amx, AMX_ERR_NATIVE, "Null traceresult provided."); + + return 0; + } + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, f3, v4, tr5, i6); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, f3, v4, tr5, i6); +#endif + + return 1; +} + +cell LOL_CDECL Call_Str_Void(AMX *amx, cell *params) +{ + SETUP(2); + +#ifdef _WIN32 + char *v=reinterpret_cast(GetFunction(pv, func))(pv, 0); +#elif defined __linux__ + char *v=reinterpret_cast(GetFunction(pv, func))(pv); +#endif + return MF_SetAmxString(amx, params[3], v == NULL ? "" : v, *MF_GetAmxAddr(amx, params[4])); + +} + +cell LOL_CDECL Call_Cbase_Void(AMX *amx, cell *params) +{ + SETUP(0); +#ifdef _WIN32 + void *ret=reinterpret_cast(GetFunction(pv, func))(pv, 0); +#elif defined __linux__ + void *ret=reinterpret_cast(GetFunction(pv, func))(pv); +#endif + return PrivateToIndex(ret); +} + +cell LOL_CDECL Call_Vector_Void(AMX *amx, cell *params) +{ + SETUP(1); +#ifdef _WIN32 + Vector ret=reinterpret_cast(GetFunction(pv, func))(pv, 0); +#elif defined __linux__ + Vector ret=reinterpret_cast(GetFunction(pv, func))(pv); +#endif + float *out=(float *)MF_GetAmxAddr(amx, params[3]); + out[0]=ret.x; + out[1]=ret.y; + out[2]=ret.z; + + return 1; +} + +cell LOL_CDECL Call_Vector_pVector(AMX *amx, cell *params) +{ + SETUP(2); + + Vector v3; + float *fl3=(float *)MF_GetAmxAddr(amx, params[3]); + v3.x=fl3[0]; + v3.y=fl3[1]; + v3.z=fl3[2]; + +#ifdef _WIN32 + Vector ret=reinterpret_cast(GetFunction(pv, func))(pv, 0, &v3); +#elif defined __linux__ + Vector ret=reinterpret_cast(GetFunction(pv, func))(pv, &v3); +#endif + float *out=(float *)MF_GetAmxAddr(amx, params[4]); + out[0]=ret.x; + out[1]=ret.y; + out[2]=ret.z; + + fl3[0]=v3.x; + fl3[1]=v3.y; + fl3[2]=v3.z; + + return 1; +} + +cell LOL_CDECL Call_Int_pVector(AMX *amx, cell *params) +{ + SETUP(1); + + Vector v3; + float *fl3=(float *)MF_GetAmxAddr(amx, params[3]); + v3.x=fl3[0]; + v3.y=fl3[1]; + v3.z=fl3[2]; + +#ifdef _WIN32 + int ret=reinterpret_cast(GetFunction(pv, func))(pv, 0, &v3); +#elif defined __linux__ + int ret=reinterpret_cast(GetFunction(pv, func))(pv, &v3); +#endif + + fl3[0]=v3.x; + fl3[1]=v3.y; + fl3[2]=v3.z; + + return ret; +} + +cell LOL_CDECL Call_Void_Entvar_Float_Float(AMX *amx, cell *params) +{ + SETUP(3); + + int id3=*MF_GetAmxAddr(amx, params[3]); + float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4])); + float f5=amx_ctof2(*MF_GetAmxAddr(amx, params[5])); + + CHECK_ENTITY(id3); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3, f4, f5); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, ev3, f4, f5); +#endif + + return 1; +} + +cell LOL_CDECL Call_Int_pFloat_pFloat(AMX *amx, cell *params) +{ + SETUP(2); + + float f3=amx_ctof2(*MF_GetAmxAddr(amx, params[3])); + float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4])); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, &f3, &f4); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, &f3, &f4); +#endif + +} + +cell LOL_CDECL Call_Void_Entvar_Float(AMX *amx, cell *params) +{ + SETUP(2); + + int id3=*MF_GetAmxAddr(amx, params[3]); + float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4])); + + CHECK_ENTITY(id3); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3, f4); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, ev3, f4); +#endif +} + diff --git a/dlls/hamsandwich/call_funcs.h b/dlls/hamsandwich/call_funcs.h new file mode 100644 index 00000000..150a3009 --- /dev/null +++ b/dlls/hamsandwich/call_funcs.h @@ -0,0 +1,54 @@ +#ifndef HOOK_Call_H +#define HOOK_Call_H + + +int Call_Void_Void(AMX *amx, cell *params); + +int Call_Int_Void(AMX *amx, cell *params); + +int Call_Void_Entvar(AMX *amx, cell *params); + +int Call_Void_Cbase(AMX *amx, cell *params); + +int Call_Int_Float_Int(AMX *amx, cell *params); + +int Call_Void_Entvar_Int(AMX *amx, cell *params); + +int Call_Int_Cbase(AMX *amx, cell *params); + +int Call_Void_Int_Int(AMX *amx, cell *params); + +int Call_Int_Int_Str_Int(AMX *amx, cell *params); + +int Call_Int_Int(AMX *amx, cell *params); + +int Call_Int_Entvar(AMX *amx, cell *params); + +int Call_Int_Entvar_Entvar_Float_Int(AMX *amx, cell *params); + +int Call_Void_Int(AMX *amx, cell *params); + +int Call_Void_Cbase_Cbase_Int_Float(AMX *amx, cell *params); + +int Call_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, cell *params); + +int Call_Void_Float_Vector_TraceResult_Int(AMX *amx, cell *params); + +int Call_Str_Void(AMX *amx, cell *params); + +int Call_Cbase_Void(AMX *amx, cell *params); + +int Call_Vector_Void(AMX *amx, cell *params); + +int Call_Vector_pVector(AMX *amx, cell *params); + +int Call_Int_pVector(AMX *amx, cell *params); + +int Call_Void_Entvar_Float_Float(AMX *amx, cell *params); + +int Call_Int_pFloat_pFloat(AMX *amx, cell *params); + +int Call_Void_Entvar_Float(AMX *amx, cell *params); + + +#endif diff --git a/dlls/hamsandwich/celltotype.h b/dlls/hamsandwich/celltotype.h new file mode 100644 index 00000000..57f4581a --- /dev/null +++ b/dlls/hamsandwich/celltotype.h @@ -0,0 +1,54 @@ +#ifndef CELLTOTYPE_H +#define CELLTOTYPE_H + +#include +#include "sdk/amxxmodule.h" + +#include "CVector.h" + +#include "hook.h" +#include "forward.h" + +#include "ham_const.h" +#include "ham_utils.h" + +inline void CellToType(const AMX*& amx, const cell& in, int& out) +{ + out=static_cast(in); +} + +inline void CellToType(const AMX*& amx, const cell& in, float& out) +{ + out=amx_ctof2(in); +} + +inline void CellToType(const AMX*& amx, const cell& in, edict_t*& out) +{ + out=INDEXENT_NEW(in); +} + +inline void CellToType(const AMX*& amx, const cell& in, entvars_t*& out) +{ + out=&(INDEXENT_NEW(in)->v); +} + +inline void CellToType(const AMX*& amx, const cell& in, HLBaseEntity*& out) +{ + out=(HLBaseEntity *)(INDEXENT_NEW(in)->pvPrivateData); +} + +inline void CellToType(const AMX*& amx, const cell& in, Vector& out) +{ + float *v=(float *)MF_GetAmxAddr(amx, in); + + out.x=v[0]; + out.y=v[1]; + out.z=v[2]; +} + +inline void CellToType(const AMX*& amx, const cell& in, TraceResult*& out) +{ + out=reinterpret_cast(in); +} + +#endif diff --git a/dlls/hamsandwich/config/hamdata.ini b/dlls/hamsandwich/config/hamdata.ini new file mode 100644 index 00000000..df7f0b0b --- /dev/null +++ b/dlls/hamsandwich/config/hamdata.ini @@ -0,0 +1,690 @@ +; Ham Sandwich module config file. +; +; IMPORTANT: It is highly suggested that you do not modify this file unless +; you know _exactly_ what you are doing! +; +; NOTE: Just because a mod contains a function does not means it will work +; as expected. If, for example, HamKilled() does not work as you think +; it should in Counter-Strike DO NOT FILE A BUG REPORT. This just +; exposes the function for you, whether or not it works, or how it +; works is up to plugin authors to figure out. +; +; NOTE: If a mod is missing keys for a certain native, that particular native +; will not be loaded! Example: Say CS is missing the "takedamage" index +; but has the use and pev indexes. The HamUse and HamePdataCbase natives +; will be registered, but the HamTakeDamage native will not register. +; In addition, any attempts to hook a function who's key is missing will +; result in the plugin failing. +; +; NOTE: The base key is only needed for the linux configs. +; +; NOTE: Any keys that begin with a modname (eg: cstrike_restart) will, +; obviously, only work on that mod and all mirrors of it (eg: czero). +; +; NOTE: If you change this file while the module is already loaded, you will +; need to restart the server for the changes to take effect. Changes to +; this file before the module is loaded will take effect when the module +; loads. +; +; NOTE: All of these offsets and settings are for the latest (at the time of +; release) legitimate version of the mod. However, there is a _chance_ +; that they will work on older (and even newer) versions. +; eg: If they work on non-Steam CS 1.6 this is coincidental, if they do +; not work on non-Steam CS 1.6 this will not be officially fixed. +; +; Mirrors: These take the name of one mod, and copy all of its data to another +; name. An example of a use for this would be cstrike and czero: they +; use the same binary so all of its vtable offsets are guaranteed to +; be identical. Mirrors should always come first in the file! +; +; Version: $Id$ + + +@mirror cstrike czero +@mirror ns nsp +@mirror esf esf_openbeta + +; TODO: check these - all are estimates +@section cstrike linux + pev 0 + base 0x94 + + spawn 2 + precache 3 + cstrike_restart 4 + keyvalue 5 + objectcaps 8 + activate 9 + setobjectcollisionbox 10 + classify 11 + deathnotice 12 + traceattack 13 + takedamage 14 + takehealth 15 + killed 16 + bloodcolor 17 + tracebleed 18 + istriggered 19 + gettogglestate 22 + addpoints 23 + addpointstoteam 24 + addplayeritem 25 + removeplayeritem 26 + giveammo 27 + getdelay 28 + ismoving 29 + overridereset 30 + damagedecal 31 + settogglestate 32 + startsneaking 33 + stopsneaking 34 + oncontrols 35 + issneaking 36 + isalive 37 + isbspmodel 38 + reflectgauss 39 + hastarget 40 + isinworld 41 + isplayer 42 + isnetclient 43 + teamid 44 + getnexttarget 45 + think 46 + touch 47 + use 48 + blocked 49 + respawn 50 + updateowner 51 + fbecomeprone 52 + center 53 + eyeposition 54 + earposition 55 + bodytarget 56 + illumination 57 + fvisible 58 + fvecvisible 59 +@end +@section cstrike windows + pev 4 + base 0x0 + + spawn 0 + precache 1 + cstrike_restart 2 + keyvalue 3 + objectcaps 6 + activate 7 + setobjectcollisionbox 8 + classify 9 + deathnotice 10 + traceattack 11 + takedamage 12 + takehealth 13 + killed 14 + bloodcolor 15 + tracebleed 16 + istriggered 17 + gettogglestate 20 + addpoints 21 + addpointstoteam 22 + addplayeritem 23 + removeplayeritem 24 + giveammo 25 + getdelay 26 + ismoving 27 + overridereset 28 + damagedecal 29 + settogglestate 30 + startsneaking 31 + stopsneaking 32 + oncontrols 33 + issneaking 34 + isalive 35 + isbspmodel 36 + reflectgauss 37 + hastarget 38 + isinworld 39 + isplayer 40 + isnetclient 41 + teamid 42 + getnexttarget 43 + think 44 + touch 45 + use 46 + blocked 47 + respawn 48 + updateowner 49 + fbecomeprone 50 + center 51 + eyeposition 52 + earposition 53 + bodytarget 54 + illumination 55 + fvisible 56 + fvecvisible 57 +@end +@section dod linux + pev 0 + base 0x154 + + dod_roundrespawn 2 + dod_roundrespawnent 3 + dod_roundstore 4 + spawn 5 + precache 6 + keyvalue 7 + objectcaps 10 + activate 11 + dod_areasetindex 12 + dod_areasendstatus 13 + objectcollisionbox 14 + classify 15 + deathnotice 16 + dod_getstate 17 + dod_getstateent 18 + traceattack 19 + takedamage 20 + takehealth 21 + killed 22 + bloodcolor 23 + tracebleed 24 + gettogglestate 27 + addpoints 28 + addpointstoteam 29 + addplayeritem 30 + removeplayeritem 31 + giveammo 32 + getdelay 33 + ismoving 34 + overridereset 35 + damagedecal 36 + settogglestate 37 + startsneaking 38 + stopsneaking 39 + oncontrols 40 + issneaking 41 + isalive 42 + isbspmodel 43 + reflectgauss 44 + hastarget 45 + isinworld 46 + isplayer 47 + isnetclient 48 + teamid 49 + getnexttarget 50 + touch 51 + think 52 + use 53 + blocked 54 + respawn 55 + updateowner 56 + fbecomeprone 57 + center 58 + eyeposition 59 + earposition 60 + bodytarget 61 + illumination 62 + fvisible 63 + fvecvisible 64 +@end +@section dod windows + pev 4 + base 0x0 + + dod_roundrespawn 0 + dod_roundrespawnent 1 + dod_roundstore 2 + spawn 3 + precache 4 + keyvalue 5 + objectcaps 8 + activate 9 + dod_areasetindex 10 + dod_areasendstatus 11 + objectcollisionbox 12 + classify 13 + deathnotice 14 + dod_getstate 15 + dod_getstateent 16 + traceattack 17 + takedamage 18 + takehealth 19 + killed 20 + bloodcolor 21 + tracebleed 22 + gettogglestate 25 + addpoints 26 + addpointstoteam 27 + addplayeritem 28 + removeplayeritem 29 + giveammo 30 + getdelay 31 + ismoving 32 + overridereset 33 + damagedecal 34 + settogglestate 35 + startsneaking 36 + stopsneaking 37 + oncontrols 48 + issneaking 39 + isalive 40 + isbspmodel 41 + reflectgauss 42 + hastarget 43 + isinworld 44 + isplayer 45 + isnetclient 46 + teamid 47 + getnexttarget 48 + touch 49 + think 50 + use 51 + blocked 52 + respawn 53 + updateowner 54 + fbecomeprone 55 + center 56 + eyeposition 57 + earposition 58 + bodytarget 59 + illumination 60 + fvisible 61 + fvecvisible 62 +@end + +; TFC Does not have the following "standard" entries in its vtable: +; addpoints, addpointstoteam +@section tfc linux + pev 0 + base 0x470 + + spawn 3 + precache 4 + keyvalue 5 + objectcaps 8 + activate 9 + setobjectcollisionbox 10 + classify 11 + deathnotice 12 + traceattack 13 + takedamage 14 + takehealth 15 + killed 16 + bloodcolor 17 + tracebleed 18 + istriggered 19 + gettogglestate 22 + addplayeritem 23 + removeplayeritem 24 + giveammo 25 + getdelay 26 + ismoving 27 + overridereset 28 + damagedecal 29 + settogglestate 30 + startsneaking 31 + stopsneaking 32 + oncontrols 33 + issneaking 34 + isalive 35 + isbspmodel 36 + reflectgauss 37 + hastarget 38 + isinworld 39 + isplayer 40 + isnetclient 41 + tfc_dbgetitemname 42 + getnexttarget 43 + think 44 + touch 45 + use 46 + blocked 47 + respawn 48 + updateowner 49 + fbecomeprone 50 + center 51 + eyeposition 52 + earposition 53 + bodytarget 54 + illumination 55 + fvisible 56 + fvecvisible 57 + tfc_engineeruse 58 + tfc_finished 59 + tfc_empexplode 60 + tfc_calcempdmgrad 61 + tfc_takeempblast 62 + tfc_empremove 63 + tfc_takeconcussionblast 64 + tfc_concuss 65 +@end +@section tfc windows + pev 4 + base 0x0 + + spawn 1 + precache 2 + keyvalue 3 + objectcaps 6 + activate 7 + setobjectcollisionbox 8 + classify 9 + deathnotice 10 + traceattack 11 + takedamage 12 + takehealth 13 + killed 14 + bloodcolor 15 + tracebleed 16 + istriggered 17 + gettogglestate 20 + addplayeritem 21 + removeplayeritem 22 + giveammo 23 + getdelay 24 + ismoving 25 + overridereset 26 + damagedecal 27 + settogglestate 28 + startsneaking 29 + stopsneaking 30 + oncontrols 31 + issneaking 32 + isalive 33 + isbspmodel 34 + reflectgauss 35 + hastarget 36 + isinworld 37 + isplayer 38 + isnetclient 39 + tfc_dbgetitemname 40 + getnexttarget 41 + think 42 + touch 43 + use 44 + blocked 45 + respawn 46 + updateowner 47 + fbecomeprone 48 + center 49 + eyeposition 50 + earposition 51 + bodytarget 52 + illumination 53 + fvisible 54 + fvecvisible 55 + tfc_engineeruse 56 + tfc_finished 57 + tfc_empexplode 58 + tfc_calcempdmgrad 59 + tfc_takeempblast 60 + tfc_empremove 61 + tfc_takeconcussionblast 62 + tfc_concuss 63 +@end +; ns's linux binary is compiled with gcc 3.3, so the "base" is 0, and pev is 4 +@section ns linux + pev 4 + base 0x0 + + spawn 1 + precache 2 + keyvalue 3 + objectcaps 6 + activate 7 + setobjectcollisionbox 8 + classify 9 + deathnotice 10 + traceattack 11 + takedamage 12 + takehealth 13 + ns_getpointvalue 14 + killed 15 + ns_awardkill 16 + bloodcolor 17 + tracebleed 18 + istriggered 19 + gettogglestate 22 + addpoints 23 + addpointstoteam 24 + addplayeritem 25 + removeplayeritem 26 + giveammo 27 + getdelay 28 + ismoving 29 + overridereset 30 + damagedecal 31 + settogglestate 32 + startsneaking 33 + stopsneaking 34 + oncontrols 35 + issneaking 36 + isalive 37 + isbspmodel 38 + reflectgauss 39 + hastarget 40 + isinworld 41 + isplayer 42 + isnetclient 43 + teamid 44 + ns_resetentity 46 + getnexttarget 47 + think 48 + touch 49 + use 50 + blocked 51 + ns_updateonremove 52 + respawn 53 + updateowner 54 + fbecomeprone 55 + center 56 + eyeposition 57 + earposition 58 + bodytarget 59 + illumination 60 + fvisible 61 + fvecvisible 62 +@end +@section ns windows + pev 4 + base 0x0 + + spawn 0 + precache 1 + keyvalue 2 + objectcaps 5 + activate 6 + setobjectcollisionbox 7 + classify 8 + deathnotice 9 + traceattack 10 + takedamage 11 + takehealth 12 + ns_getpointvalue 13 + killed 14 + ns_awardkill 15 + bloodcolor 16 + tracebleed 17 + istriggered 18 + gettogglestate 21 + addpoints 22 + addpointstoteam 23 + addplayeritem 24 + removeplayeritem 25 + giveammo 26 + getdelay 27 + ismoving 28 + overridereset 29 + damagedecal 30 + settogglestate 31 + startsneaking 32 + stopsneaking 33 + oncontrols 34 + issneaking 35 + isalive 36 + isbspmodel 37 + reflectgauss 38 + hastarget 39 + isinworld 40 + isplayer 41 + isnetclient 42 + teamid 43 + ns_resetentity 45 + getnexttarget 46 + think 47 + touch 48 + use 49 + blocked 50 + ns_updateonremove 51 + respawn 52 + updateowner 53 + fbecomeprone 54 + center 55 + eyeposition 56 + earposition 57 + bodytarget 58 + illumination 59 + fvisible 60 + fvecvisible 61 +@end + +@section ts linux + pev 0 + base 0x60 + + ts_breakablerespawn 2 + ts_canusedthroughwalls 3 + ts_respawnwait 4 + spawn 5 + precache 6 + keyvalue 7 + objectcaps 10 + activate 11 + setobjectcollisionbox 12 + classify 13 + deathnotice 14 + traceattack 15 + takedamage 16 + takehealth 17 + killed 18 + bloodcolor 19 + tracebleed 20 + istriggered 21 + gettogglestate 24 + addpoints 25 + addpointstoteam 26 + addplayeritem 27 + removeplayeritem 28 + giveammo 29 + getdelay 30 + ismoving 31 + overridereset 32 + damagedecal 33 + settogglestate 34 + startsneaking 35 + stopsneaking 36 + oncontrols 37 + issneaking 38 + isalive 39 + isbspmodel 40 + reflectgauss 41 + hastarget 42 + isinworld 43 + isplayer 44 + isnetclient 45 + teamid 46 + getnexttarget 47 + think 48 + touch 49 + use 50 + blocked 51 + respawn 52 + updateowner 53 + fbecomeprone 54 + center 55 + eyeposition 56 + earposition 57 + bodytarget 58 + illumination 59 + fvisible 60 + fvecvisible 61 +@end +@section ts windows + pev 4 + base 0x0 + + ts_breakablerespawn 0 + ts_canusedthroughwalls 1 + ts_respawnwait 2 + spawn 3 + precache 4 + keyvalue 5 + objectcaps 8 + activate 9 + setobjectcollisionbox 10 + classify 11 + deathnotice 12 + traceattack 13 + takedamage 14 + takehealth 15 + killed 16 + bloodcolor 17 + tracebleed 18 + istriggered 19 + gettogglestate 22 + addpoints 23 + addpointstoteam 24 + addplayeritem 25 + removeplayeritem 26 + giveammo 27 + getdelay 28 + ismoving 29 + overridereset 30 + damagedecal 31 + settogglestate 32 + startsneaking 33 + stopsneaking 34 + oncontrols 35 + issneaking 36 + isalive 37 + isbspmodel 38 + reflectgauss 39 + hastarget 40 + isinworld 41 + isplayer 42 + isnetclient 43 + teamid 44 + getnexttarget 45 + think 46 + touch 47 + use 48 + blocked 49 + respawn 50 + updateowner 51 + fbecomeprone 52 + center 53 + eyeposition 54 + earposition 55 + bodytarget 56 + illumination 57 + fvisible 58 + fvecvisible 59 +@end + +; Sven-Coop has no linux binaries. This makes disassembly much harder. +@section svencoop windows + pev 4 + base 0x0 + + takedamage 11 + use 46 +@end + +; ESF also has no linux binaries. +@section esf windows + pev 4 + base 0x0 + + takedamage 12 + use 46 +@end diff --git a/dlls/hamsandwich/config_parser.cpp b/dlls/hamsandwich/config_parser.cpp new file mode 100644 index 00000000..547dedc4 --- /dev/null +++ b/dlls/hamsandwich/config_parser.cpp @@ -0,0 +1,369 @@ +#include "sdk/amxxmodule.h" + +#include "ham_const.h" +#include "hooklist.h" +#include "offsets.h" + +extern hook_t hooklist[]; + +enum +{ + LEX_INVALID = 0, + + LEX_UNKNOWN, + + LEX_START_SEC, + LEX_END_SEC, + + LEX_MIRROR, + + LEX_PEV, + LEX_BASE, + + LEX_END +}; + +const char *tokens[] = +{ + "", // LEX_INVALID + + "", // LEX_UNKNOWN + + "@section", // LEX_START_SEC + "@end", // LEX_END_SEC + + "@mirror", // LEX_MIRROR + + "pev", // LEX_PEV + "base", // LEX_BASE + + "", // LEX_END +}; + +static void trim_line(char *input); +static void read_mirror(char *input); +static void skip_to_end_of_section(FILE *fp); +static int lex(char*& buffer); + +int lex(char*& buffer) +{ + trim_line(buffer); + + size_t len; + + for (int i=0; i oldinput && + ( *start == '\0' || + *start == ' ' || + *start == '\r' || + *start == '\n' || + *start == '\t')) + { + start--; + } + start++; + *start='\0'; + + // Now find any comments and cut off at the start + + while (*start != '\0') + { + if (*start == ';') + { + *start='\0'; + break; + } + + start++; + } +} + +void skip_to_end_of_section(FILE *fp) +{ + char buffer[1024]; + + while (!feof(fp)) + { + buffer[0]='\0'; + + fgets(buffer, sizeof(buffer)-1, fp); + + trim_line(buffer); + + char *b=&buffer[0]; + if (lex(b)==LEX_END_SEC) + { + break; + } + } +} +static const char* get_localinfo( const char* name , const char* def = 0 ) +{ + const char* b = LOCALINFO( (char*)name ); + if (((b==0)||(*b==0)) && def ) + SET_LOCALINFO((char*)name,(char*)(b = def) ); + return b; +} +int read_start_section(char *data) +{ + printf("Section: %s\n", data); + if (strncmp(data, CurrentModName, strlen(CurrentModName))==0) + { + data+=strlen(CurrentModName)+1; + trim_line(data); + +#ifdef _WIN32 + if (strcmp(data, "windows")==0) +#elif defined __linux__ + if (strcmp(data, "linux")==0) +#endif + { + return 1; + } + } + return 0; +} +int read_number(char *input) +{ + char *end; /* Temporary pointer, needed for strtoul(). */ + + // if begins with 0x or 0X it's to be interpretted as hex + if (*input=='0' && + (*(input+1)=='x' || *(input+1)=='X')) + { + return strtoul(input,&end,16); + } + + // otherwise it's to be interpretted as base 10 + return strtoul(input,&end,10); +} +void process_pev(char *data) +{ + trim_line(data); + Offsets.SetPev(read_number(data)); +} +void process_base(char *data) +{ + trim_line(data); + Offsets.SetBase(read_number(data)); +} +void process_key(char *data) +{ + size_t size=0; + + char *a=data; + + while (*a != ' ' && *a != '\t' && *a != '\0') + { + a++; + size++; + } + + int set=0; + for (int i=0; i< HAM_LAST_ENTRY_DONT_USE_ME_LOL; i++) + { + if (strncmp(data, hooklist[i].name, size)==0) + { + data+=size+1; + + trim_line(data); + int value=read_number(data); + + hooklist[i].isset=1; + hooklist[i].vtid=value; + + printf("setting \"%s\" to %d", hooklist[i].name, hooklist[i].vtid); + + set=1; + break; + + } + } + + if (set==0) + { + printf("stray key in process_key: %s", data); + } + +} +int ReadConfig(void) +{ + char FileName[512]; + + MF_BuildPathnameR(FileName,sizeof(FileName)-1,"%s",get_localinfo("amxx_configsdir","addons/amxmodx/configs")); + + strncat(FileName,"/hamdata.ini",sizeof(FileName)-1); + + FILE *fp=fopen(FileName,"r"); + + + snprintf(CurrentModName, sizeof(CurrentModName)-1, "%s", MF_GetModname()); + + if (!fp) + { + MF_Log("Unable to open \"%s\" for reading.", FileName); + + return -1; + } + + char data[2048]; + + int insec=0; + + while (!feof(fp)) + { + data[0]='\0'; + + fgets(data, sizeof(data)-1, fp); + + char *b=&data[0]; + + switch(lex(b)) + { + case LEX_PEV: + { + if (insec) + { + process_pev(b); + } + break; + }; + case LEX_BASE: + { + if (insec) + { + process_base(b); + } + break; + }; + case LEX_MIRROR: + { + read_mirror(b); + break; + }; + case LEX_START_SEC: + { + insec=read_start_section(b); + + if (!insec) + { + skip_to_end_of_section(fp); + } + break; + }; + case LEX_END_SEC: + { + insec=0; + break; + }; + case LEX_UNKNOWN: + { + if (insec) + { + process_key(b); + } + }; + } + + + } + + return 1; +} diff --git a/dlls/hamsandwich/ecall_funcs.cpp b/dlls/hamsandwich/ecall_funcs.cpp new file mode 100644 index 00000000..543cf0b2 --- /dev/null +++ b/dlls/hamsandwich/ecall_funcs.cpp @@ -0,0 +1,479 @@ +#include "sdk/amxxmodule.h" + +#include "offsets.h" +#include "ham_utils.h" +#include "hooklist.h" + +#include "CVector.h" +#include "forward.h" +#include "hook.h" + + +extern CVector hooks[HAM_LAST_ENTRY_DONT_USE_ME_LOL]; + +void FailPlugin(AMX *amx, int id, int err, const char *reason); + +inline void *GetFunction(void *pthis, int id) +{ + void **vtbl=GetVTable(pthis, Offsets.GetBase()); + + int **ivtbl=(int **)vtbl; + void *func=ivtbl[hooklist[id].vtid]; + + return func; +} + +#define SETUP(NUMARGS) \ + if (((NUMARGS + 2) * sizeof(cell)) > (unsigned)params[0]) \ + { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Bad arg count. Expected %d, got %d.", NUMARGS + 2, params[0] / sizeof(cell)); \ + return 0; \ + } \ + int func=params[1]; \ + int id=params[2]; \ + CHECK_FUNCTION(func); \ + CHECK_ENTITY(id); \ + void *pv=IndexToPrivate(id); + + +cell eCall_Void_Void(AMX *amx, cell *params) +{ + SETUP(0); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv); +#endif + return 1; +} + +cell eCall_Int_Void(AMX *amx, cell *params) +{ + SETUP(0); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv); +#endif +} + +cell eCall_Void_Entvar(AMX *amx, cell *params) +{ + SETUP(1); + + int id3=*MF_GetAmxAddr(amx, params[3]); + + CHECK_ENTITY(id3); + + entvars_t *ev1=&(INDEXENT_NEW(id3)->v); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, ev1); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, ev1); +#endif + return 1; +} + + +cell eCall_Void_Cbase(AMX *amx, cell *params) +{ + SETUP(1); + + int id3=*MF_GetAmxAddr(amx, params[3]); + + CHECK_ENTITY(id3); + + void *pv1=(INDEXENT_NEW(id3)->pvPrivateData); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, pv1); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, pv1); +#endif + return 1; +} + +cell eCall_Int_Float_Int(AMX *amx, cell *params) +{ + SETUP(2); + + float f3=amx_ftoc2(*MF_GetAmxAddr(amx, params[3])); + int i4=*MF_GetAmxAddr(amx, params[4]); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, f3, i4); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, f3, i4); +#endif +} + + +cell eCall_Void_Entvar_Int(AMX *amx, cell *params) +{ + SETUP(2); + + int id3=*MF_GetAmxAddr(amx, params[3]); + int i4=*MF_GetAmxAddr(amx, params[4]); + + CHECK_ENTITY(id3); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3, i4); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, ev3, i4); +#endif + return 1; +} + + +cell eCall_Int_Cbase(AMX *amx, cell *params) +{ + SETUP(1); + + int id3=*MF_GetAmxAddr(amx, params[3]); + + CHECK_ENTITY(id3); + + void *pv1=(INDEXENT_NEW(id3)->pvPrivateData); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, pv1); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, pv1); +#endif +} + +cell eCall_Void_Int_Int(AMX *amx, cell *params) +{ + SETUP(2); + + int i3=*MF_GetAmxAddr(amx, params[3]); + int i4=*MF_GetAmxAddr(amx, params[4]); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, i3, i4); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, i3, i4); +#endif + return 1; +} + +cell eCall_Int_Int_Str_Int(AMX *amx, cell *params) +{ + + SETUP(3); + + int i3=*MF_GetAmxAddr(amx, params[3]); + char *sz4=MF_GetAmxString(amx, params[4], 0, NULL); + int i5=*MF_GetAmxAddr(amx, params[5]); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, i3, sz4, i5); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, i3, sz4, i5); +#endif +} + +cell eCall_Int_Int(AMX *amx, cell *params) +{ + SETUP(1); + + int i3=*MF_GetAmxAddr(amx, params[3]); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, i3); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, i3); +#endif +} + +cell eCall_Int_Entvar(AMX *amx, cell *params) +{ + SETUP(1); + + int id3=*MF_GetAmxAddr(amx, params[3]); + + CHECK_ENTITY(id3); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, ev3); +#endif +} + +cell eCall_Int_Entvar_Entvar_Float_Int(AMX *amx, cell *params) +{ + SETUP(4); + + int id3=*MF_GetAmxAddr(amx, params[3]); + int id4=*MF_GetAmxAddr(amx, params[4]); + float f5=amx_ctof2(*MF_GetAmxAddr(amx, params[5])); + int i6=*MF_GetAmxAddr(amx, params[6]); + + CHECK_ENTITY(id3); + CHECK_ENTITY(id4); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); + entvars_t *ev4=&(INDEXENT_NEW(id4)->v); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3, ev4, f5, i6); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, ev3, ev4, f5, i6); +#endif +} + +cell eCall_Void_Int(AMX *amx, cell *params) +{ + SETUP(1); + + int i3=*MF_GetAmxAddr(amx, params[3]); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, i3); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, i3); +#endif + + return 1; +} + +cell eCall_Void_Cbase_Cbase_Int_Float(AMX *amx, cell *params) +{ + SETUP(4); + + int id3=*MF_GetAmxAddr(amx, params[3]); + int id4=*MF_GetAmxAddr(amx, params[4]); + int i5=*MF_GetAmxAddr(amx, params[5]); + float f6=amx_ctof(*MF_GetAmxAddr(amx, params[6])); + + CHECK_ENTITY(id3); + CHECK_ENTITY(id4); + + void *p3=IndexToPrivate(id3); + void *p4=IndexToPrivate(id4); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, p3, p4, i5, f6); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, p3, p4, i5, f6); +#endif + + return 1; +} + +cell eCall_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, cell *params) +{ + SETUP(5); + + int id3=*MF_GetAmxAddr(amx, params[3]); + float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4])); + Vector v5; + TraceResult *tr6=reinterpret_cast(*MF_GetAmxAddr(amx, params[6])); + int i7=*MF_GetAmxAddr(amx, params[7]); + + float *fl5=(float *)MF_GetAmxAddr(amx, params[5]); + v5.x=fl5[0]; + v5.y=fl5[1]; + v5.z=fl5[2]; + + if (tr6==NULL) + { + MF_LogError(amx, AMX_ERR_NATIVE, "Null traceresult provided."); + + return 0; + } + + CHECK_ENTITY(id3); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3, f4, v5, tr6, i7); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, ev3, f4, v5, tr6, i7); +#endif + + return 1; +} + +cell eCall_Void_Float_Vector_TraceResult_Int(AMX *amx, cell *params) +{ + SETUP(4); + + float f3=amx_ctof2(*MF_GetAmxAddr(amx, params[3])); + Vector v4; + TraceResult *tr5=reinterpret_cast(*MF_GetAmxAddr(amx, params[5])); + int i6=*MF_GetAmxAddr(amx, params[6]); + + float *fl4=(float *)MF_GetAmxAddr(amx, params[4]); + v4.x=fl4[0]; + v4.y=fl4[1]; + v4.z=fl4[2]; + + if (tr5==NULL) + { + MF_LogError(amx, AMX_ERR_NATIVE, "Null traceresult provided."); + + return 0; + } + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, f3, v4, tr5, i6); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, f3, v4, tr5, i6); +#endif + + return 1; +} + +cell eCall_Str_Void(AMX *amx, cell *params) +{ + SETUP(2); + +#ifdef _WIN32 + char *v=reinterpret_cast(GetFunction(pv, func))(pv, 0); +#elif defined __linux__ + char *v=reinterpret_cast(GetFunction(pv, func))(pv); +#endif + return MF_SetAmxString(amx, params[3], v == NULL ? "" : v, *MF_GetAmxAddr(amx, params[4])); + +} + +cell eCall_Cbase_Void(AMX *amx, cell *params) +{ + SETUP(0); +#ifdef _WIN32 + void *ret=reinterpret_cast(GetFunction(pv, func))(pv, 0); +#elif defined __linux__ + void *ret=reinterpret_cast(GetFunction(pv, func))(pv); +#endif + return PrivateToIndex(ret); +} + +cell eCall_Vector_Void(AMX *amx, cell *params) +{ + SETUP(1); +#ifdef _WIN32 + Vector ret=reinterpret_cast(GetFunction(pv, func))(pv, 0); +#elif defined __linux__ + Vector ret=reinterpret_cast(GetFunction(pv, func))(pv); +#endif + float *out=(float *)MF_GetAmxAddr(amx, params[3]); + out[0]=ret.x; + out[1]=ret.y; + out[2]=ret.z; + + return 1; +} + +cell eCall_Vector_pVector(AMX *amx, cell *params) +{ + SETUP(2); + + Vector v3; + float *fl3=(float *)MF_GetAmxAddr(amx, params[3]); + v3.x=fl3[0]; + v3.y=fl3[1]; + v3.z=fl3[2]; + +#ifdef _WIN32 + Vector ret=reinterpret_cast(GetFunction(pv, func))(pv, 0, &v3); +#elif defined __linux__ + Vector ret=reinterpret_cast(GetFunction(pv, func))(pv, &v3); +#endif + float *out=(float *)MF_GetAmxAddr(amx, params[4]); + out[0]=ret.x; + out[1]=ret.y; + out[2]=ret.z; + + fl3[0]=v3.x; + fl3[1]=v3.y; + fl3[2]=v3.z; + + return 1; +} + +cell eCall_Int_pVector(AMX *amx, cell *params) +{ + SETUP(1); + + Vector v3; + float *fl3=(float *)MF_GetAmxAddr(amx, params[3]); + v3.x=fl3[0]; + v3.y=fl3[1]; + v3.z=fl3[2]; + +#ifdef _WIN32 + int ret=reinterpret_cast(GetFunction(pv, func))(pv, 0, &v3); +#elif defined __linux__ + int ret=reinterpret_cast(GetFunction(pv, func))(pv, &v3); +#endif + + fl3[0]=v3.x; + fl3[1]=v3.y; + fl3[2]=v3.z; + + return ret; +} + +cell eCall_Void_Entvar_Float_Float(AMX *amx, cell *params) +{ + SETUP(3); + + int id3=*MF_GetAmxAddr(amx, params[3]); + float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4])); + float f5=amx_ctof2(*MF_GetAmxAddr(amx, params[5])); + + CHECK_ENTITY(id3); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); + +#ifdef _WIN32 + reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3, f4, f5); +#elif defined __linux__ + reinterpret_cast(GetFunction(pv, func))(pv, ev3, f4, f5); +#endif + + return 1; +} + +cell eCall_Int_pFloat_pFloat(AMX *amx, cell *params) +{ + SETUP(2); + + float f3=amx_ctof2(*MF_GetAmxAddr(amx, params[3])); + float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4])); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, &f3, &f4); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, &f3, &f4); +#endif + +} + +cell eCall_Void_Entvar_Float(AMX *amx, cell *params) +{ + SETUP(2); + + int id3=*MF_GetAmxAddr(amx, params[3]); + float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4])); + + CHECK_ENTITY(id3); + + entvars_t *ev3=&(INDEXENT_NEW(id3)->v); + +#ifdef _WIN32 + return reinterpret_cast(GetFunction(pv, func))(pv, 0, ev3, f4); +#elif defined __linux__ + return reinterpret_cast(GetFunction(pv, func))(pv, ev3, f4); +#endif +} diff --git a/dlls/hamsandwich/ecall_funcs.h b/dlls/hamsandwich/ecall_funcs.h new file mode 100644 index 00000000..e7bbfaf3 --- /dev/null +++ b/dlls/hamsandwich/ecall_funcs.h @@ -0,0 +1,54 @@ +#ifndef HOOK_ECALL_H +#define HOOK_ECALL_H + + +int eCall_Void_Void(AMX *amx, cell *params); + +int eCall_Int_Void(AMX *amx, cell *params); + +int eCall_Void_Entvar(AMX *amx, cell *params); + +int eCall_Void_Cbase(AMX *amx, cell *params); + +int eCall_Int_Float_Int(AMX *amx, cell *params); + +int eCall_Void_Entvar_Int(AMX *amx, cell *params); + +int eCall_Int_Cbase(AMX *amx, cell *params); + +int eCall_Void_Int_Int(AMX *amx, cell *params); + +int eCall_Int_Int_Str_Int(AMX *amx, cell *params); + +int eCall_Int_Int(AMX *amx, cell *params); + +int eCall_Int_Entvar(AMX *amx, cell *params); + +int eCall_Int_Entvar_Entvar_Float_Int(AMX *amx, cell *params); + +int eCall_Void_Int(AMX *amx, cell *params); + +int eCall_Void_Cbase_Cbase_Int_Float(AMX *amx, cell *params); + +int eCall_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, cell *params); + +int eCall_Void_Float_Vector_TraceResult_Int(AMX *amx, cell *params); + +int eCall_Str_Void(AMX *amx, cell *params); + +int eCall_Cbase_Void(AMX *amx, cell *params); + +int eCall_Vector_Void(AMX *amx, cell *params); + +int eCall_Vector_pVector(AMX *amx, cell *params); + +int eCall_Int_pVector(AMX *amx, cell *params); + +int eCall_Void_Entvar_Float_Float(AMX *amx, cell *params); + +int eCall_Int_pFloat_pFloat(AMX *amx, cell *params); + +int eCall_Void_Entvar_Float(AMX *amx, cell *params); + + +#endif diff --git a/dlls/hamsandwich/forward.h b/dlls/hamsandwich/forward.h new file mode 100644 index 00000000..61bf7719 --- /dev/null +++ b/dlls/hamsandwich/forward.h @@ -0,0 +1,40 @@ +#include "sdk/amxxmodule.h" + +#ifndef FORWARD_H +#define FORWARD_H + +enum fwdstate +{ + FSTATE_INVALID = 0, + FSTATE_OK, + FSTATE_PAUSE, + FSTATE_STOP, + FSTATE_DESTROY +}; + +class Forward +{ +public: + int id; // id of the forward + fwdstate state; + Forward(int id_) : id(id_), state(FSTATE_OK) + { + /* do nothing */ + }; + Forward() : id(-1), state(FSTATE_INVALID) + { + /* do nothing */ + } + ~Forward() + { + MF_UnregisterSPForward(id); + } + inline void Set(int i) + { + state=FSTATE_OK; + id=i; + }; + +}; + +#endif diff --git a/dlls/hamsandwich/ham_const.h b/dlls/hamsandwich/ham_const.h new file mode 100644 index 00000000..5cb737b0 --- /dev/null +++ b/dlls/hamsandwich/ham_const.h @@ -0,0 +1,113 @@ +#ifndef HAM_CONST_H +#define HAM_CONST_H + + +enum +{ + HAM_UNSET = 0, + HAM_IGNORED, + HAM_HANDLED, + HAM_OVERRIDE, + HAM_SUPERCEDE +}; + +enum +{ + Ham_Spawn = 0, + Ham_Precache, + Ham_Keyvalue, + Ham_ObjectCaps, + Ham_Activate, + Ham_SetObjectCollisionBox, + Ham_Classify, + Ham_DeathNotice, + Ham_TraceAttack, + Ham_TakeDamage, + Ham_TakeHealth, + Ham_Killed, + Ham_BloodColor, + Ham_TraceBleed, + Ham_IsTriggered, + Ham_GetToggleState, + Ham_AddPoints, + Ham_AddPointsToTeam, + Ham_AddPlayerItem, + Ham_RemovePlayerItem, + Ham_GiveAmmo, + Ham_GetDelay, + Ham_IsMoving, + Ham_OverrideReset, + Ham_DamageDecal, + Ham_SetToggleState, + Ham_StartSneaking, + Ham_StopSneaking, + Ham_OnControls, + Ham_IsSneaking, + Ham_IsAlive, + Ham_IsBSPModel, + Ham_ReflectGauss, + Ham_HasTarget, + Ham_IsInWorld, + Ham_IsPlayer, + Ham_IsNetClient, + Ham_TeamId, + Ham_GetNextTarget, + Ham_Think, + Ham_Touch, + Ham_Use, + Ham_Blocked, + Ham_Respawn, + Ham_UpdateOwner, + Ham_FBecomeProne, + Ham_Center, + Ham_EyePosition, + Ham_EarPosition, + Ham_BodyTarget, + Ham_Illumination, + Ham_FVisible, + Ham_FVecVisible, + + Ham_TS_BreakableRespawn, + Ham_TS_CanUsedThroughWalls, + Ham_TS_RespawnWait, + + Ham_CS_Restart, + + Ham_DOD_RoundRespawn, + Ham_DOD_RoundRespawnEnt, + Ham_DOD_RoundStore, + Ham_DOD_AreaSetIndex, + Ham_DOD_AreaSendStatus, + Ham_DOD_GetState, + Ham_DOD_GetStateEnt, + + Ham_TFC_DbGetItemName, + Ham_TFC_EngineerUse, + Ham_TFC_Finished, + Ham_TFC_EmpExplode, + Ham_TFC_CalcEmpDmgRad, + Ham_TFC_TakeEmpBlast, + Ham_TFC_EmpRemove, + Ham_TFC_TakeConcussionBlast, + Ham_TFC_Concuss, + + Ham_NS_GetPointValue, + Ham_NS_AwardKill, + Ham_NS_ResetEntity, + Ham_NS_UpdateOnRemove, + + + HAM_LAST_ENTRY_DONT_USE_ME_LOL +}; + +enum +{ + HAM_OK = 0, + + HAM_INVALID_FUNC, // The function is not valid + HAM_FUNC_NOT_CONFIGURED, // This function is not configured in hamdata.ini + + HAM_ERR_END +}; + +#endif diff --git a/dlls/hamsandwich/ham_utils.h b/dlls/hamsandwich/ham_utils.h new file mode 100644 index 00000000..99492d34 --- /dev/null +++ b/dlls/hamsandwich/ham_utils.h @@ -0,0 +1,124 @@ +#ifndef HAM_UTILS_H +#define HAM_UTILS_H + +#include "sdk/amxxmodule.h" +#include "offsets.h" +#include "NEW_Util.h" + +#define CHECK_FUNCTION(x) \ + if (x < 0 || x > HAM_LAST_ENTRY_DONT_USE_ME_LOL) { \ + FailPlugin(amx, x, HAM_INVALID_FUNC, "Function out of bounds."); \ + return 0; \ + } else if (hooklist[x].isset == 0) { \ + FailPlugin(amx, x, HAM_FUNC_NOT_CONFIGURED, "Function not configured in hamdata.ini"); \ + return 0; \ + } + + +#define CHECK_ENTITY(x) \ + if (x < 0 || x > gpGlobals->maxEntities) { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Entity out of range (%d)", x); \ + return 0; \ + } else { \ + if (INDEXENT_NEW(x)->free) { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Invalid entity (%d)", x); \ + return 0; \ + } else if (INDEXENT_NEW(x)->pvPrivateData == NULL) { \ + MF_LogError(amx, AMX_ERR_NATIVE, "Entity has null private data (%d)", x); \ + return 0; \ + } \ + } + +inline edict_t *PrivateToEdict(const void *pdata) +{ + + if (!pdata) + { + return NULL; + } + + char *ptr=(char*)pdata + Offsets.GetPev(); + entvars_t *pev=(entvars_t *)ptr; + + if (!pev) + { + return NULL; + } + return pev->pContainingEntity; +}; + +inline int PrivateToIndex(const void *pdata) +{ + + if (pdata==NULL) + { + return -1; + } + char *ptr=(char*)pdata; + + ptr+=Offsets.GetPev(); + + entvars_t *pev=*(entvars_t **)ptr; + + + if (pev==NULL) + { + return -1; + } + + if (pev->pContainingEntity==NULL) + { + return -1; + } + + return ENTINDEX_NEW(pev->pContainingEntity); +}; +inline void *IndexToPrivate(int index) +{ + return INDEXENT_NEW(index)->pvPrivateData; +}; + +inline int EntvarToIndex(entvars_t *pev) +{ + if (pev==NULL) + { + return -1; + } + + if (pev->pContainingEntity==NULL) + { + return -1; + } + + return ENTINDEX_NEW(pev->pContainingEntity); +}; + +inline edict_t *EntvarToEdict(entvars_t *pev) +{ + if (pev==NULL) + { + return NULL; + } + + return pev->pContainingEntity; +}; +inline void **EdictToVTable(edict_t *ent) +{ + char *btbl=(char *)ent->pvPrivateData; + btbl+=Offsets.GetBase(); + return *((void ***)btbl); +}; + +inline void **GetVTable(void *pthis, int size) +{ + return *((void***)(((char*)pthis)+size)); +} +inline void *GetVTableEntry(void *pthis, int ventry, int size) +{ + void **vtbl=GetVTable(pthis, size); + + return vtbl[ventry]; +} + +void print_srvconsole(char *fmt, ...); +#endif diff --git a/dlls/hamsandwich/hook.h b/dlls/hamsandwich/hook.h new file mode 100644 index 00000000..c676aa59 --- /dev/null +++ b/dlls/hamsandwich/hook.h @@ -0,0 +1,80 @@ +#ifndef HOOK_H +#define HOOK_H + +#include "forward.h" +#include "Trampolines.h" + +// This is just a simple container for data so I only have to add 1 extra +// parameter to calls that get trampolined + +class Hook +{ +public: + CVector pre; // pre forwards + CVector post; // post forwards + void *func; // original function + void **vtable; // vtable of the original location + int entry; // vtable entry of the function + void *target; // target function being called (the hook) + int exec; // 1 when this hook is in execution + int del; // 1 if this hook should be destroyed after exec + void *tramp; // trampoline for this hook + char *ent; // ent name that's being hooked + + Hook(void **vtable_, int entry_, void *target_, bool voidcall, int paramcount, char *name) : + func(NULL), vtable(vtable_), entry(entry_), target(target_), exec(0), del(0), tramp(NULL) + { + // original function is vtable[entry] + // to not make the compiler whine, cast vtable to int ** + int **ivtable=(int **)vtable; + func=(void *)ivtable[entry]; + + // now install a trampoline + // (int thiscall, int voidcall, int paramcount, void *extraptr) + tramp=CreateGenericTrampoline(true, voidcall, paramcount, (void*)this, target); + + // Insert into vtable +#if defined _WIN32 + DWORD OldFlags; + VirtualProtect(&ivtable[entry],sizeof(int*),PAGE_READWRITE,&OldFlags); +#elif defined __linux__ + mprotect(&ivtable[entry],sizeof(int*),PROT_READ|PROT_WRITE); +#endif + ivtable[entry]=(int*)tramp; + + size_t len=strlen(name); + ent=new char[len+1]; + + snprintf(ent,len+1,"%s",name); + }; + + ~Hook() + { + // Insert the original function back into the vtable + int **ivtable=(int **)vtable; + +#if defined _WIN32 + DWORD OldFlags; + VirtualProtect(&ivtable[entry],sizeof(int*),PAGE_READWRITE,&OldFlags); +#elif defined __linux__ + mprotect(&ivtable[entry],sizeof(int*),PROT_READ|PROT_WRITE); +#endif + + ivtable[entry]=(int *)func; + + free(tramp); + + delete[] ent; + + CVector::iterator end=pre.end(); + + for (CVector::iterator i=pre.begin(); + i!=end; + ++i) + { + delete (*i); + } + } +}; + +#endif diff --git a/dlls/hamsandwich/hook_callbacks.cpp b/dlls/hamsandwich/hook_callbacks.cpp new file mode 100644 index 00000000..24a960c5 --- /dev/null +++ b/dlls/hamsandwich/hook_callbacks.cpp @@ -0,0 +1,563 @@ +#include +#include +#include +#include + +#include +#include "sdk/amxxmodule.h" + + + +#include "CVector.h" + +#include "hook.h" +#include "forward.h" + +#include "ham_const.h" +#include "ham_utils.h" + + +#define PRE_START() \ + int result=HAM_UNSET; \ + int thisresult=HAM_UNSET; \ + int iThis=PrivateToIndex(pthis); \ + CVector::iterator end=hook->pre.end(); \ + for (CVector::iterator i=hook->pre.begin(); i!=end; i++) \ + { \ + if ((*i)->state == FSTATE_OK) \ + { \ + printf("id=%d\n",(*i)->id); \ + thisresult=MF_ExecuteForward((*i)->id,iThis + +#define PRE_END() \ + ); \ + } \ + if (thisresult > result) \ + { \ + result=thisresult; \ + } \ + } \ + if (result < HAM_SUPERCEDE) \ + { + +#define POST_START() \ + } \ + end=hook->post.end(); \ + for (CVector::iterator i=hook->post.begin(); i!=end; i++)\ + { \ + if ((*i)->state == FSTATE_OK) \ + { \ + MF_ExecuteForward((*i)->id,iThis + +#define POST_END() \ + ); \ + } \ + } + + +void Hook_Void_Void(Hook *hook, void *pthis) +{ + PRE_START() + PRE_END() + +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis,0); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis); +#endif + + POST_START() + POST_END() +} +int Hook_Int_Void(Hook *hook, void *pthis) +{ + int ireturn=0; + + PRE_START() + PRE_END() + + +#if defined _WIN32 + ireturn=reinterpret_cast(hook->func)(pthis,0); +#elif defined __linux__ + ireturn=reinterpret_cast(hook->func)(pthis); +#endif + + POST_START() + POST_END() + + return ireturn; +} + +void Hook_Void_Entvar(Hook *hook, void *pthis, entvars_t *entvar) +{ + int iOther=EntvarToIndex(entvar); + + PRE_START() + , iOther + PRE_END() + +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis, 0, entvar); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis, entvar); +#endif + + POST_START() + , iOther + POST_END() + +} + +void Hook_Void_Cbase(Hook *hook, void *pthis, void *other) +{ + int iOther=PrivateToIndex(other); + + PRE_START() + , iOther + PRE_END() + +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis, 0, other); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis, other); +#endif + + POST_START() + , iOther + POST_END() + + +} + +int Hook_Int_Float_Int(Hook *hook, void *pthis, float f1, int i1) +{ + int ireturn=0; + PRE_START() + , f1, i1 + PRE_END() + +#if defined _WIN32 + ireturn=reinterpret_cast(hook->func)(pthis, 0, f1, i1); +#elif defined __linux__ + ireturn=reinterpret_cast(hook->func)(pthis, f1, i1); +#endif + + POST_START() + , f1, i1 + POST_END() + + return ireturn; + +} +void Hook_Void_Entvar_Int(Hook *hook, void *pthis, entvars_t *ev1, int i1) +{ + int iOther=EntvarToIndex(ev1); + + PRE_START() + , iOther, i1 + PRE_END() + +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis, 0, ev1, i1); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis, ev1, i1); +#endif + + POST_START() + , iOther, i1 + POST_END() +} + +int Hook_Int_Cbase(Hook *hook, void *pthis, void *cb1) +{ + int iOther=PrivateToIndex(cb1); + int ireturn=0; + PRE_START() + , iOther + PRE_END() +#if defined _WIN32 + ireturn=reinterpret_cast(hook->func)(pthis, 0, cb1); +#elif defined __linux__ + ireturn=reinterpret_cast(hook->func)(pthis, cb1); +#endif + + POST_START() + , iOther + POST_END() + + return ireturn; +} + +void Hook_Void_Int_Int(Hook *hook, void *pthis, int i1, int i2) +{ + PRE_START() + ,i1, i2 + PRE_END() +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis, 0, i1, i2); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis, i1, i2); +#endif + + POST_START() + ,i1, i2 + POST_END() +} + +int Hook_Int_Int_Str_Int(Hook *hook, void *pthis, int i1, const char *sz1, int i2) +{ + int ireturn=0; + PRE_START() + ,i1, sz1, i2 + PRE_END() +#if defined _WIN32 + ireturn=reinterpret_cast(hook->func)(pthis, 0, i1, sz1, i2); +#elif defined __linux__ + ireturn=reinterpret_cast(hook->func)(pthis, i1, sz1, i2); +#endif + + POST_START() + ,i1, sz1, i2 + POST_END() + + return ireturn; +} + +int Hook_Int_Int(Hook *hook, void *pthis, int i1) +{ + int ireturn=0; + + PRE_START() + ,i1 + PRE_END() + +#if defined _WIN32 + ireturn=reinterpret_cast(hook->func)(pthis, 0, i1); +#elif defined __linux__ + ireturn=reinterpret_cast(hook->func)(pthis, i1); +#endif + + POST_START() + ,i1 + POST_END() + + return ireturn; +} + +int Hook_Int_Entvar(Hook *hook, void *pthis, entvars_t *ev1) +{ + int ireturn=0; + int iOther=EntvarToIndex(ev1); + + PRE_START() + ,iOther + PRE_END() + +#if defined _WIN32 + ireturn=reinterpret_cast(hook->func)(pthis, 0, ev1); +#elif defined __linux__ + ireturn=reinterpret_cast(hook->func)(pthis, ev1); +#endif + + POST_START() + , iOther + POST_END() + + return ireturn; +} + + + +// Takedamage +int Hook_Int_Entvar_Entvar_Float_Int(Hook *hook, void *pthis, entvars_t *inflictor, entvars_t *attacker, float damage, int damagebits) +{ + int ireturn=0; + int iInflictor=EntvarToIndex(inflictor); + int iAttacker=EntvarToIndex(attacker); + + + PRE_START() + ,iInflictor, iAttacker, damage, damagebits + PRE_END() + + +#if defined _WIN32 + ireturn=reinterpret_cast(hook->func)(pthis, 0, inflictor, attacker, damage, damagebits); +#elif defined __linux__ + ireturn=reinterpret_cast(hook->func)(pthis, inflictor, attacker, damage, damagebits); +#endif + + POST_START() + ,iInflictor, iAttacker, damage, damagebits + POST_END() + + return ireturn; +} + +void Hook_Void_Int(Hook *hook, void *pthis, int i1) +{ + PRE_START() + , i1 + PRE_END() + +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis, 0, i1); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis, i1); +#endif + + POST_START() + ,i1 + POST_END() + +} + +void Hook_Void_Cbase_Cbase_Int_Float(Hook *hook, void *pthis, void *cb1, void *cb2, int i1, float f1) +{ + int iCaller=PrivateToIndex(cb1); + int iActivator=PrivateToIndex(cb2); + + + PRE_START() + ,iCaller, iActivator, i1, f1 + PRE_END() + + +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis, 0, cb1, cb2, i1, f1); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis, cb1, cb2, i1, f1); +#endif + + POST_START() + ,iCaller, iActivator, i1, f1 + POST_END() + +} + +void Hook_Void_Entvar_Float_Vector_Trace_Int(Hook *hook, void *pthis, entvars_t *ev1, float f1, Vector v1, TraceResult *tr1, int i1) +{ + int iev1=EntvarToIndex(ev1); + cell cvec[3]; + cvec[0]=amx_ftoc2(v1.x); + cvec[1]=amx_ftoc2(v1.y); + cvec[2]=amx_ftoc2(v1.z); + + PRE_START() + ,iev1, f1, MF_PrepareCellArrayA(cvec, 3, false), tr1, i1 + PRE_END() + +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis, 0, ev1, f1, v1, tr1, i1); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis, ev1, f1, v1, tr1, i1); +#endif + + POST_START() + , iev1, f1, MF_PrepareCellArrayA(cvec, 3, false), tr1, i1 + POST_END() +} + +void Hook_Void_Float_Vector_TraceResult_Int(Hook *hook, void *pthis, float f1, Vector v1, TraceResult *tr1, int i1) +{ + cell cvec[3]; + cvec[0]=amx_ftoc2(v1.x); + cvec[1]=amx_ftoc2(v1.y); + cvec[2]=amx_ftoc2(v1.z); + + PRE_START() + , f1, MF_PrepareCellArrayA(cvec, 3, false), tr1, i1 + PRE_END() + +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis, 0, f1, v1, tr1, i1); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis, f1, v1, tr1, i1); +#endif + + POST_START() + , f1, MF_PrepareCellArrayA(cvec, 3, false), tr1, i1 + POST_END() +} +const char *Hook_Str_Void(Hook *hook, void *pthis) +{ + const char *ret=NULL; + PRE_START() + PRE_END() + +#if defined _WIN32 + ret=reinterpret_cast(hook->func)(pthis, 0); +#elif defined __linux__ + ret=reinterpret_cast(hook->func)(pthis); +#endif + + POST_START() + POST_END() + + return ret; + +} + +void *Hook_Cbase_Void(Hook *hook, void *pthis) +{ + void *ret=NULL; + PRE_START() + PRE_END() + +#if defined _WIN32 + ret=reinterpret_cast(hook->func)(pthis, 0); +#elif defined __linux__ + ret=reinterpret_cast(hook->func)(pthis); +#endif + + POST_START() + POST_END() + + return ret; + +} + + +Vector Hook_Vector_Void(Hook *hook, void *pthis) +{ + Vector ret; + + memset(&ret, 0x0, sizeof(Vector)); + + PRE_START() + PRE_END() + +#if defined _WIN32 + ret=reinterpret_cast(hook->func)(pthis, 0); +#elif defined __linux__ + ret=reinterpret_cast(hook->func)(pthis); +#endif + + POST_START() + POST_END() + + return ret; + +} + +Vector Hook_Vector_pVector(Hook *hook, void *pthis, Vector *v1) +{ + Vector ret; + + memset(&ret, 0x0, sizeof(Vector)); + + cell cv1[3]; + cv1[0]=amx_ftoc2(v1->x); + cv1[1]=amx_ftoc2(v1->y); + cv1[2]=amx_ftoc2(v1->z); + + PRE_START() + , MF_PrepareCellArrayA(cv1, 3, false) + PRE_END() + +#if defined _WIN32 + ret=reinterpret_cast(hook->func)(pthis, 0, v1); +#elif defined __linux__ + ret=reinterpret_cast(hook->func)(pthis, v1); +#endif + + POST_START() + , MF_PrepareCellArrayA(cv1, 3, false) + POST_END() + + return ret; + +} + +int Hook_Int_pVector(Hook *hook, void *pthis, Vector *v1) +{ + int ret=0; + + cell cv1[3]; + + cv1[0]=amx_ftoc2(v1->x); + cv1[1]=amx_ftoc2(v1->y); + cv1[2]=amx_ftoc2(v1->z); + + PRE_START() + , MF_PrepareCellArrayA(cv1, 3, false) + PRE_END() + +#if defined _WIN32 + ret=reinterpret_cast(hook->func)(pthis, 0, v1); +#elif defined __linux__ + ret=reinterpret_cast(hook->func)(pthis, v1); +#endif + + POST_START() + , MF_PrepareCellArrayA(cv1, 3, false) + POST_END() + + return ret; + +} + +void Hook_Void_Entvar_Float_Float(Hook *hook, void *pthis, entvars_t *ev1, float f1, float f2) +{ + cell cev1=EntvarToIndex(ev1); + + PRE_START() + , cev1, f1, f2 + PRE_END() + +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis, 0, ev1, f1, f2); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis, ev1, f1, f2); +#endif + + POST_START() + , cev1, f1, f2 + POST_END() + +} + +int Hook_Int_pFloat_pFloat(Hook *hook, void *pthis, float *f1, float *f2) +{ + int ret=0; + + cell cf1=amx_ftoc2(f1 == NULL ? 0.0 : *f1); + cell cf2=amx_ftoc2(f2 == NULL ? 0.0 : *f2); + + PRE_START() + , cf1, cf2 + PRE_END() + +#if defined _WIN32 + ret=reinterpret_cast(hook->func)(pthis, 0, f1, f2); +#elif defined __linux__ + ret=reinterpret_cast(hook->func)(pthis, f1, f2); +#endif + + POST_START() + , cf1, cf2 + POST_END() + + return ret; +} + +void Hook_Void_Entvar_Float(Hook *hook, void *pthis, entvars_t *ev1, float f1) +{ + cell cev1=EntvarToIndex(ev1); + + PRE_START() + , cev1, f1 + PRE_END() + +#if defined _WIN32 + reinterpret_cast(hook->func)(pthis, 0, ev1, f1); +#elif defined __linux__ + reinterpret_cast(hook->func)(pthis, ev1, f1); +#endif + + POST_START() + , cev1, f1 + POST_END() +} + diff --git a/dlls/hamsandwich/hook_callbacks.h b/dlls/hamsandwich/hook_callbacks.h new file mode 100644 index 00000000..cc44a025 --- /dev/null +++ b/dlls/hamsandwich/hook_callbacks.h @@ -0,0 +1,67 @@ + +#ifndef HOOK_CALLBACKS_H +#define HOOK_CALLBACKS_H + + +void Hook_Void_Void(Hook *hook, void *pthis); + +int Hook_Int_Void(Hook *hook, void *pthis); + +void Hook_Void_Entvar(Hook *hook, void *pthis, entvars_t *entvar); + +void Hook_Void_Cbase(Hook *hook, void *pthis, void *other); + +int Hook_Int_Float_Int(Hook *hook, void *pthis, float f1, int i1); + +void Hook_Void_Entvar_Int(Hook *hook, void *ptis, entvars_t *ev1, int i1); + +int Hook_Int_Cbase(Hook *hook, void *pthis, void *cb1); + +void Hook_Void_Int_Int(Hook *hook, void *pthis, int i1, int i2); + +int Hook_Int_Int_Str_Int(Hook *hook, void *pthis, int i1, const char *sz1, + int i2); + +int Hook_Int_Int(Hook *hook, void *pthis, int i1); + +int Hook_Int_Entvar(Hook *hook, void *pthis, entvars_t *ev1); + +int Hook_Int_Entvar_Entvar_Float_Int(Hook *hook, void *pthis, + entvars_t *inflictor, + entvars_t *attacker, float damage, + int damagebits); + +void Hook_Void_Int(Hook *hook, void *pthis, int i1); + +void Hook_Void_Cbase_Cbase_Int_Float(Hook *hook, void *pthis, void *cb1, + void *cb2, int i1, float f1); + +void Hook_Void_Entvar_Float_Vector_Trace_Int(Hook *hook, void *pthis, + entvars_t *ev1, float f1, + Vector v1, TraceResult *tr1, + int i1); + +void Hook_Void_Float_Vector_TraceResult_Int(Hook *hook, void *pthis, float f1, + Vector v1, TraceResult *tr1, + int i1); + +const char *Hook_Str_Void(Hook *hook, void *pthis); + +void *Hook_Cbase_Void(Hook *hook, void *pthis); + +Vector Hook_Vector_Void(Hook *hook, void *pthis); + +Vector Hook_Vector_pVector(Hook *hook, void *pthis, Vector *v1); + +int Hook_Int_pVector(Hook *hook, void *pthis, Vector *v1); + +void Hook_Void_Entvar_Float_Float(Hook *hook, void *pthis, entvars_t *ev1, + float f1, float f2); + +int Hook_Int_pFloat_pFloat(Hook *hook, void *pthis, float *f1, + float *f2); + +void Hook_Void_Entvar_Float(Hook *hook, void *pthis, entvars_t *ev1, float f1); + + +#endif diff --git a/dlls/hamsandwich/hook_create.cpp b/dlls/hamsandwich/hook_create.cpp new file mode 100644 index 00000000..e3a623ad --- /dev/null +++ b/dlls/hamsandwich/hook_create.cpp @@ -0,0 +1,125 @@ +#include "sdk/amxxmodule.h" + +int Create_Void_Void(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_DONE); +} + +int Create_Int_Void(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_DONE); +} + +int Create_Void_Entvar(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE); +} + + +int Create_Void_Cbase(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE); +} + +int Create_Int_Float_Int(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_FLOAT, FP_CELL, FP_DONE); +} + + +int Create_Void_Entvar_Int(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_CELL, FP_DONE); +} + + +int Create_Int_Cbase(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE); +} + +int Create_Void_Int_Int(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_CELL, FP_DONE); +} + +int Create_Int_Int_Str_Int(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_STRING, FP_CELL, FP_DONE); +} + +int Create_Int_Int(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE); +} + +int Create_Int_Entvar(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE); +} + +int Create_Int_Entvar_Entvar_Float_Int(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_CELL, FP_FLOAT, FP_CELL, FP_DONE); +} + +int Create_Void_Int(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE); +} + +int Create_Void_Cbase_Cbase_Int_Float(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_FLOAT, FP_DONE); +} + +int Create_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_FLOAT, FP_ARRAY, FP_CELL, FP_CELL, FP_DONE); +} + +int Create_Void_Float_Vector_TraceResult_Int(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_FLOAT, FP_ARRAY, FP_CELL, FP_CELL, FP_DONE); +} + +int Create_Str_Void(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_DONE); +} + +int Create_Cbase_Void(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_DONE); +} + +int Create_Vector_Void(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_DONE); +} + +int Create_Vector_pVector(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_ARRAY, FP_DONE); +} + +int Create_Int_pVector(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_ARRAY, FP_DONE); +} + +int Create_Void_Entvar_Float_Float(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_FLOAT, FP_FLOAT, FP_DONE); +} + +int Create_Int_pFloat_pFloat(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_CELL, FP_DONE); +} + +int Create_Void_Entvar_Float(AMX *amx, const char *func) +{ + return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_FLOAT, FP_DONE); +} + diff --git a/dlls/hamsandwich/hook_create.h b/dlls/hamsandwich/hook_create.h new file mode 100644 index 00000000..26189700 --- /dev/null +++ b/dlls/hamsandwich/hook_create.h @@ -0,0 +1,54 @@ +#ifndef HOOK_CREATE_H +#define HOOK_CREATE_H + + +int Create_Void_Void(AMX *amx, const char *func); + +int Create_Int_Void(AMX *amx, const char *func); + +int Create_Void_Entvar(AMX *amx, const char *func); + +int Create_Void_Cbase(AMX *amx, const char *func); + +int Create_Int_Float_Int(AMX *amx, const char *func); + +int Create_Void_Entvar_Int(AMX *amx, const char *func); + +int Create_Int_Cbase(AMX *amx, const char *func); + +int Create_Void_Int_Int(AMX *amx, const char *func); + +int Create_Int_Int_Str_Int(AMX *amx, const char *func); + +int Create_Int_Int(AMX *amx, const char *func); + +int Create_Int_Entvar(AMX *amx, const char *func); + +int Create_Int_Entvar_Entvar_Float_Int(AMX *amx, const char *func); + +int Create_Void_Int(AMX *amx, const char *func); + +int Create_Void_Cbase_Cbase_Int_Float(AMX *amx, const char *func); + +int Create_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, const char *func); + +int Create_Void_Float_Vector_TraceResult_Int(AMX *amx, const char *func); + +int Create_Str_Void(AMX *amx, const char *func); + +int Create_Cbase_Void(AMX *amx, const char *func); + +int Create_Vector_Void(AMX *amx, const char *func); + +int Create_Vector_pVector(AMX *amx, const char *func); + +int Create_Int_pVector(AMX *amx, const char *func); + +int Create_Void_Entvar_Float_Float(AMX *amx, const char *func); + +int Create_Int_pFloat_pFloat(AMX *amx, const char *func); + +int Create_Void_Entvar_Float(AMX *amx, const char *func); + + +#endif diff --git a/dlls/hamsandwich/hook_native.cpp b/dlls/hamsandwich/hook_native.cpp new file mode 100644 index 00000000..d38c8b82 --- /dev/null +++ b/dlls/hamsandwich/hook_native.cpp @@ -0,0 +1,267 @@ +#include +#include +#include +#include + +#include +#include "sdk/amxxmodule.h" + + +#include "CVector.h" + +#include "hook.h" +#include "forward.h" +#include "hook_callbacks.h" +#include "call_funcs.h" +#include "ecall_funcs.h" +#include "hook_create.h" +#include "offsets.h" +#include "hooklist.h" +#include "ham_utils.h" + +OffsetManager Offsets; + +CVector hooks[HAM_LAST_ENTRY_DONT_USE_ME_LOL]; + + +#define V(__STUFF__) reinterpret_cast(Hook_##__STUFF__), Create_##__STUFF__, Call_##__STUFF__, eCall_##__STUFF__ + +hook_t hooklist[] = +{ + { 0, 0, "spawn", true, 0, V(Void_Void) }, // Spawn + { 0, 0, "precache", true, 0, V(Void_Void) }, // Precache + { 0, 0, "keyvalue", true, 1, V(Void_Int) }, // Keyvalue + { 0, 0, "objectcaps", false, 0, V(Int_Void) }, // ObjectCaps + { 0, 0, "activate", true, 0, V(Void_Void) }, // Activate + { 0, 0, "setobjectcollisionbox", true, 0, V(Void_Void) }, // SetObjectCollisionBox + { 0, 0, "classify", false, 0, V(Int_Void) }, // Classify + { 0, 0, "deathnotice", true, 1, V(Void_Entvar) }, // DeathNotice + { 0, 0, "traceattack", true, 7, V(Void_Entvar_Float_Vector_Trace_Int) }, // TraceAttack + { 0, 0, "takedamage", false, 4, V(Int_Entvar_Entvar_Float_Int) }, // Takedamage + { 0, 0, "takehealth", false, 2, V(Int_Float_Int) }, // TakeHealth + { 0, 0, "killed", true, 2, V(Void_Entvar_Int) }, // Killed + { 0, 0, "bloodcolor", false, 0, V(Int_Void) }, // BloodColor + { 0, 0, "tracebleed", true, 6, V(Void_Float_Vector_TraceResult_Int) }, // TraceBleed + { 0, 0, "istriggered", false, 1, V(Int_Cbase) }, // IsTriggered + { 0, 0, "gettogglestate", false, 0, V(Int_Void) }, // GetToggleState + { 0, 0, "addpoints", true, 2, V(Void_Int_Int) }, // AddPoints + { 0, 0, "addpointstoteam", true, 2, V(Void_Int_Int) }, // AddPointsToTeam + { 0, 0, "addplayeritem", false, 1, V(Int_Cbase) }, // AddPlayerItem + { 0, 0, "removeplayeritem", false, 1, V(Int_Cbase) }, // RemovePlayerItem + { 0, 0, "giveammo", false, 3, V(Int_Int_Str_Int) }, // GiveAmmo + { 0, 0, "getdelay", false, 0, V(Int_Void) }, // GetDelay + { 0, 0, "ismoving", false, 0, V(Int_Void) }, // IsMoving + { 0, 0, "overridereset", true, 0, V(Void_Void) }, // OverrideReset + { 0, 0, "damagedecal", false, 1, V(Int_Int) }, // DamageDecal + { 0, 0, "settogglestate", true, 1, V(Void_Int) }, // SetToggleState + { 0, 0, "startsneaking", true, 0, V(Void_Void) }, // StartSneaking + { 0, 0, "stopsneaking", true, 0, V(Void_Void) }, // StopSneaking + { 0, 0, "oncontrols", false, 1, V(Int_Entvar) }, // OnControls + { 0, 0, "issneaking", false, 0, V(Int_Void) }, // IsSneaking + { 0, 0, "isalive", false, 0, V(Int_Void) }, // IsAlive + { 0, 0, "isbspmodel", false, 0, V(Int_Void) }, // IsBSPModel + { 0, 0, "reflectgauss", false, 0, V(Int_Void) }, // ReflectGauss + { 0, 0, "hastarget", false, 1, V(Int_Int) }, // HasTarget + { 0, 0, "isinworld", false, 0, V(Int_Void) }, // IsInWorld + { 0, 0, "isplayer", false, 0, V(Int_Void) }, // IsPlayer + { 0, 0, "isnetclient", false, 0, V(Int_Void) }, // IsNetClient + { 0, 0, "teamid", false, 0, V(Str_Void) }, // TeamID + { 0, 0, "getnexttarget", false, 0, V(Cbase_Void) }, // GetNextTarget + { 0, 0, "think", true, 0, V(Void_Void) }, // Think + { 0, 0, "touch", true, 1, V(Void_Cbase) }, // Touch + { 0, 0, "use", true, 4, V(Void_Cbase_Cbase_Int_Float) }, // Use + { 0, 0, "blocked", true, 1, V(Void_Cbase) }, // Blocked + { 0, 0, "respawn", false, 0, V(Cbase_Void) }, // Respawn TODO: Cbase this + { 0, 0, "updateowner", true, 0, V(Void_Void) }, // UpdateOwner + { 0, 0, "fbecomeprone", false, 0, V(Int_Void) }, // FBecomeProne + + + // TODO: These + { 0, 0, "center", false, 0, V(Vector_Void) }, // Center + { 0, 0, "eyeposition", false, 0, V(Vector_Void) }, // EyePosition + { 0, 0, "earposition", false, 0, V(Vector_Void) }, // EarPosition + { 0, 0, "bodytarget", false, 1, V(Vector_pVector) }, // BodyTarget + { 0, 0, "illumination", false, 0, V(Int_Void) }, // Illumination + { 0, 0, "fvisible", false, 1, V(Int_Cbase) }, // FVisible + { 0, 0, "fvecvisible", false, 1, V(Int_pVector) }, // FVecVisible + /** Mod specific hooks **/ + + /* The Specialists */ + { 0, 0, "ts_breakablerespawn", false, 1, V(Int_Int) }, // TS_BreakableRespawn + { 0, 0, "ts_canusedthroughwalls", false, 0, V(Int_Void) }, // TS_CanUsedThroughWalls + { 0, 0, "ts_respawnwait", false, 0, V(Int_Void) }, // TS_RespawnWait + + /* Counter-Strike */ + { 0, 0, "cstrike_restart", true, 0, V(Void_Void) }, // CS_Restart + + /* Day of Defeat */ + { 0, 0, "dod_roundrespawn", true, 0, V(Void_Void) }, // DOD_RoundRespawn + { 0, 0, "dod_roundrespawnent", true, 0, V(Void_Void) }, // DOD_RoundRespawnEnt + { 0, 0, "dod_roundstore", true, 0, V(Void_Void) }, // DOD_RoundStore + { 0, 0, "dod_areasetindex", true, 1, V(Void_Int) }, // DOD_AreaSetIndex + { 0, 0, "dod_areasendstatus", true, 1, V(Void_Cbase) }, // DOD_AreaSendStatus + { 0, 0, "dod_getstate", false, 0, V(Int_Void) }, // DOD_GetState + { 0, 0, "dod_getstateent", false, 1, V(Int_Cbase) }, // DOD_GetStateEnt + + + /* Team Fortress Classic */ + // This next one is just a huge guess + { 0, 0, "tfc_dbgetitemname", false, 0, V(Str_Void) }, // TFC_DbGetItemName + { 0, 0, "tfc_engineeruse", false, 1, V(Int_Cbase) }, // TFC_EngineerUse + { 0, 0, "tfc_finished", true, 0, V(Void_Void) }, // TFC_Finished + { 0, 0, "tfc_empexplode", true, 3, V(Void_Entvar_Float_Float) }, // TFC_EmpExplode + { 0, 0, "tfc_calcempdmgrad", false, 2, V(Int_pFloat_pFloat) }, // TFC_CalcEmpDmgRad + { 0, 0, "tfc_takeempblast", true, 1, V(Void_Entvar) }, // TFC_TakeEmpBlast + { 0, 0, "tfc_empremove", true, 0, V(Void_Void) }, // TFC_EmpRemove + { 0, 0, "tfc_takeconcussionblast", true, 2, V(Void_Entvar_Float) }, // TFC_TakeConcussionBlast + { 0, 0, "tfc_concuss", true, 1, V(Void_Entvar) }, // TFC_Concuss + + /* Natural-Selection */ + { 0, 0, "ns_getpointvalue", false, 0, V(Int_Void) }, // NS_GetPointValue + { 0, 0, "ns_awardkill", true, 1, V(Void_Entvar) }, // NS_AwardKill + { 0, 0, "ns_resetentity", true, 0, V(Void_Void) }, // NS_ResetEntity + { 0, 0, "ns_updateonremove", true, 0, V(Void_Void) }, // NS_UpdateOnRemove + +}; + + +void FailPlugin(AMX *amx, int id, int err, const char *reason) +{ + int fwd=MF_RegisterSPForwardByName(amx, "__fatal_ham_error", FP_CELL, FP_CELL, FP_STRING, FP_DONE); + + MF_ExecuteForward(fwd, id, err, reason); + + MF_UnregisterSPForward(fwd); +} +static cell AMX_NATIVE_CALL RegisterHam(AMX *amx, cell *params) +{ + // Make sure the function we're requesting is within bounds + int func=params[1]; + int post=params[4]; + + CHECK_FUNCTION(func); + + char *function=MF_GetAmxString(amx, params[2], 0, NULL); + char *classname=MF_GetAmxString(amx, params[3], 1, NULL); + + // Check the entity + + // create an entity, assign it the gamedll's class, hook it and destroy it + edict_t *Entity=CREATE_ENTITY(); + + CALL_GAME_ENTITY(PLID,classname,&Entity->v); + + if (Entity->pvPrivateData == NULL) + { + REMOVE_ENTITY(Entity); + + MF_LogError(amx, AMX_ERR_NATIVE,"Failed to retrieve classtype for \"%s\", hook for \"%s\" not active.",classname,function); + + return 0; + } + void **vtable=GetVTable(Entity->pvPrivateData, Offsets.GetBase()); + + REMOVE_ENTITY(Entity); + + if (vtable == NULL) + { + MF_LogError(amx, AMX_ERR_NATIVE,"Failed to retrieve vtable for \"%s\", hook for \"%s\" not active.",classname,function); + + return 0; + } + + // Verify that the function is valid + // Don't fail the plugin if this fails, just emit a normal error + int fwd=hooklist[func].makefunc(amx, function); + + printf("\n\n----> FORWARD = %d\n\n\n",fwd); + if (fwd == -1) + { + MF_LogError(amx, AMX_ERR_NATIVE, "Function %s not found.", function); + + return 0; + } + + // We've passed all tests... + + int **ivtable=(int **)vtable; + + void *vfunction=(void *)ivtable[hooklist[func].vtid]; + + // Check the list of this function's hooks, see if the function we have is a hook + + CVector::iterator end=hooks[func].end(); + for (CVector::iterator i=hooks[func].begin(); + i!=end; + ++i) + { + if ((*i)->tramp == vfunction) + { + // Yes, this function is hooked + if (post) + { + (*i)->post.push_back(new Forward(fwd)); + } + else + { + (*i)->pre.push_back(new Forward(fwd)); + } + return 1; + } + } + + // If we got here, the function is not hooked + Hook *hook=new Hook(vtable, hooklist[func].vtid, hooklist[func].targetfunc, hooklist[func].isvoid, hooklist[func].paramcount, classname); + hooks[func].push_back(hook); + + if (post) + { + hook->post.push_back(new Forward(fwd)); + } + else + { + hook->pre.push_back(new Forward(fwd)); + } + + return 1; +} +static cell AMX_NATIVE_CALL ExecuteHam(AMX *amx, cell *params) +{ + int func=params[1]; + + CHECK_FUNCTION(func); + + return hooklist[func].call(amx, params); +} +static cell AMX_NATIVE_CALL ExecuteHamB(AMX *amx, cell *params) +{ + int func=params[1]; + + CHECK_FUNCTION(func); + + return hooklist[func].ecall(amx, params); +} + + +static cell AMX_NATIVE_CALL IsHamValid(AMX *amx, cell *params) +{ + int func=params[1]; + + if (func >= 0 && + func < HAM_LAST_ENTRY_DONT_USE_ME_LOL && + hooklist[func].isset!=0) + { + return 1; + } + return 0; +} + +AMX_NATIVE_INFO RegisterNatives[] = +{ + { "RegisterHam", RegisterHam }, + { "ExecuteHam", ExecuteHam }, + { "ExecuteHamB", ExecuteHamB }, + { "IsHamValid", IsHamValid }, + + { NULL, NULL } +}; diff --git a/dlls/hamsandwich/hooklist.h b/dlls/hamsandwich/hooklist.h new file mode 100644 index 00000000..c33e5149 --- /dev/null +++ b/dlls/hamsandwich/hooklist.h @@ -0,0 +1,19 @@ +#ifndef HOOKLIST_T_H +#define HOOKLIST_T_H + +typedef struct hook_s +{ + int isset; // whether or not this hook is registered with hamdata + int vtid; // vtable index of this function + const char *name; // name used in the keys + bool isvoid; // whether or not the target trampoline uses voids + int paramcount; // how many parameters are in the func + void *targetfunc; // the target hook + int (*makefunc)(AMX *, const char*); // function that creates forwards + int (*call)(AMX *, cell*); // function to call the vcall + int (*ecall)(AMX *, cell*); // function to ecall the vcall +} hook_t; + +extern hook_t hooklist[]; + +#endif diff --git a/dlls/hamsandwich/include/hamsandwich.inc b/dlls/hamsandwich/include/hamsandwich.inc new file mode 100644 index 00000000..d17c6b04 --- /dev/null +++ b/dlls/hamsandwich/include/hamsandwich.inc @@ -0,0 +1,179 @@ +#if defined _hamsandwich_included + #endinput +#endif + +#define _hamsandwich_included + +enum Ham +{ + Ham_Spawn = 0, + Ham_Precache, + Ham_Keyvalue, + Ham_ObjectCaps, + Ham_Activate, + Ham_SetObjectCollisionBox, + Ham_Classify, + Ham_DeathNotice, + Ham_TraceAttack, + Ham_TakeDamage, + Ham_TakeHealth, + Ham_Killed, + Ham_BloodColor, + Ham_TraceBleed, + Ham_IsTriggered, + Ham_GetToggleState, + Ham_AddPoints, + Ham_AddPointsToTeam, + Ham_AddPlayerItem, + Ham_RemovePlayerItem, + Ham_GiveAmmo, + Ham_GetDelay, + Ham_IsMoving, + Ham_OverrideReset, + Ham_DamageDecal, + Ham_SetToggleState, + Ham_StartSneaking, + Ham_StopSneaking, + Ham_OnControls, + Ham_IsSneaking, + Ham_IsAlive, + Ham_IsBSPModel, + Ham_ReflectGauss, + Ham_HasTarget, + Ham_IsInWorld, + Ham_IsPlayer, + Ham_IsNetClient, + Ham_TeamId, + Ham_GetNextTarget, + Ham_Think, + Ham_Touch, + Ham_Use, + Ham_Blocked, + Ham_Respawn, + Ham_UpdateOwner, + Ham_FBecomeProne, + Ham_Center, + Ham_EyePosition, + Ham_EarPosition, + Ham_BodyTarget, + Ham_Illumination, + Ham_FVisible, + Ham_FVecVisible, + + Ham_TS_BreakableRespawn, + Ham_TS_CanUsedThroughWalls, + Ham_TS_RespawnWait, + + Ham_CS_Restart, + + Ham_DOD_RoundRespawn, + Ham_DOD_RoundRespawnEnt, + Ham_DOD_RoundStore, + Ham_DOD_AreaSetIndex, + Ham_DOD_AreaSendStatus, + Ham_DOD_GetState, + Ham_DOD_GetStateEnt, + + Ham_TFC_DbGetItemName, + Ham_TFC_EngineerUse, + Ham_TFC_Finished, + Ham_TFC_EmpExplode, + Ham_TFC_CalcEmpDmgRad, + Ham_TFC_TakeEmpBlast, + Ham_TFC_EmpRemove, + Ham_TFC_TakeConcussionBlast, + Ham_TFC_Concuss, + + Ham_NS_GetPointValue, + Ham_NS_AwardKill, + Ham_NS_ResetEntity, + Ham_NS_UpdateOnRemove, + + + HAM_LAST_ENTRY_DONT_USE_ME_LOL +}; + + +/** + * Hooks the virtual table for the specified entity class. + * An example would be: RegisterHam(Ham_TakeDamage, "player_hurt", "player"); + * Look at the Ham enum for parameter lists. + * + * @param function The function to hook. + * @param callback The forward to call. + * @param entity The entity classname to hook. + * @param post Whether or not to forward this in post. + */ + + +native RegisterHam(Ham:function, const callback[], const entity[], post=0); + +/** + * Executes the virtual function on the entity. + * Look at the Ham enum for parameter lists. + * + * @param function The function to call. + * @param id The id of the entity to execute it on. + */ +native ExecuteHam(Ham:function, id, any:...); + +/** + * Executes the virtual function on the entity, this will trigger all hooks on that function. + * Be very careful about recursion! + * Look at the Ham enum for parameter lists. + * + * @param function The function to call. + * @param id The id of the entity to execute it on. + */ +native ExecuteHamB(Ham:function, id, any:...); + + +/** + * Returns whether or not the function for the specified Ham is valid. + * Things that would make it invalid would be bounds (an older module version + * may not have all of the functions), and the function not being found in + * the mod's hamdata.ini file. + * + * @param function The function to look up. + * @return true if the function is valid, false otherwise. + */ +native bool:IsHamValid(Ham:function); + + +enum HamError +{ + HAM_OK = 0, + + HAM_INVALID_FUNC, // The function is not valid + HAM_FUNC_NOT_CONFIGURED, // This function is not configured in hamdata.ini + + HAM_ERR_END +}; + +// This is the callback from the module, this handles any fatal errors. +// This will in turn call the "HamFilter(Ham:id, HamError:err, const reason[])" public, if it exists. +// Return PLUGIN_HANDLED from within the HamFilter to stop the plugin from failing. +// Any other return value will fail the plugin. +// You do not need to have a HamFilter, if there is none, all fatal errors will fail the plugin. +public __fatal_ham_error(Ham:id, HamError:err, const reason[]) +{ + + new func=get_func_id("HamFilter", -1); + new bool:fail=true; + + if (callfunc_begin_i(func, -1)==1) + { + callfunc_push_int(_:id); + callfunc_push_int(_:err); + callfunc_push_str(reason, false); + if (callfunc_end()==PLUGIN_HANDLED) + { + fail=false; + } + } + if (fail) + { + set_fail_state(reason); + } + +} \ No newline at end of file diff --git a/dlls/hamsandwich/msvc7/fakemeta.sln b/dlls/hamsandwich/msvc7/fakemeta.sln new file mode 100644 index 00000000..a2143411 --- /dev/null +++ b/dlls/hamsandwich/msvc7/fakemeta.sln @@ -0,0 +1,21 @@ +Microsoft Visual Studio Solution File, Format Version 8.00 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fakemeta", "fakemeta.vcproj", "{5E393C37-22F2-4CA2-9022-6400DC582447}" + ProjectSection(ProjectDependencies) = postProject + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfiguration) = preSolution + Debug = Debug + Release = Release + EndGlobalSection + GlobalSection(ProjectConfiguration) = postSolution + {5E393C37-22F2-4CA2-9022-6400DC582447}.Debug.ActiveCfg = Debug|Win32 + {5E393C37-22F2-4CA2-9022-6400DC582447}.Debug.Build.0 = Debug|Win32 + {5E393C37-22F2-4CA2-9022-6400DC582447}.Release.ActiveCfg = Release|Win32 + {5E393C37-22F2-4CA2-9022-6400DC582447}.Release.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EndGlobalSection + GlobalSection(ExtensibilityAddIns) = postSolution + EndGlobalSection +EndGlobal diff --git a/dlls/hamsandwich/msvc7/fakemeta.vcproj b/dlls/hamsandwich/msvc7/fakemeta.vcproj new file mode 100644 index 00000000..a9b1be78 --- /dev/null +++ b/dlls/hamsandwich/msvc7/fakemeta.vcproj @@ -0,0 +1,245 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dlls/hamsandwich/msvc8/hamsandwich.sln b/dlls/hamsandwich/msvc8/hamsandwich.sln new file mode 100644 index 00000000..12459017 --- /dev/null +++ b/dlls/hamsandwich/msvc8/hamsandwich.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual Studio 2005 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hamsandwich", "hamsandwich.vcproj", "{5E393C37-22F2-4CA2-9022-6400DC582447}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {5E393C37-22F2-4CA2-9022-6400DC582447}.Debug|Win32.ActiveCfg = Debug|Win32 + {5E393C37-22F2-4CA2-9022-6400DC582447}.Debug|Win32.Build.0 = Debug|Win32 + {5E393C37-22F2-4CA2-9022-6400DC582447}.Release|Win32.ActiveCfg = Release|Win32 + {5E393C37-22F2-4CA2-9022-6400DC582447}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/dlls/hamsandwich/msvc8/hamsandwich.vcproj b/dlls/hamsandwich/msvc8/hamsandwich.vcproj new file mode 100644 index 00000000..9c731541 --- /dev/null +++ b/dlls/hamsandwich/msvc8/hamsandwich.vcproj @@ -0,0 +1,305 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dlls/hamsandwich/offsets.h b/dlls/hamsandwich/offsets.h new file mode 100644 index 00000000..98aec275 --- /dev/null +++ b/dlls/hamsandwich/offsets.h @@ -0,0 +1,55 @@ +#ifndef OFFSETS_H +#define OFFSETS_H + +#include "ham_const.h" + +// Just a singleton class that keeps pev/base/offset values managed. + +class OffsetManager +{ +private: + size_t pev; + size_t baseclass; + int baseset; + int pevset; + +public: + OffsetManager() + { + memset(this,0x0,sizeof(*this)); + } + void SetPev(size_t value) + { + pevset=1; + pev=value; + }; + size_t GetPev(void) + { + return pev; + }; + int IsPevSet() + { + return pevset; + }; + int IsBaseSet() + { + return baseset; + }; + void SetBase(size_t value) + { + baseset=1; + baseclass=value; + }; + size_t GetBase(void) + { + return baseclass; + }; + bool IsValid() + { + return pevset != 0 && baseset != 0; + } +}; + +extern OffsetManager Offsets; + +#endif diff --git a/dlls/hamsandwich/sdk/amxxmodule.cpp b/dlls/hamsandwich/sdk/amxxmodule.cpp new file mode 100644 index 00000000..83067916 --- /dev/null +++ b/dlls/hamsandwich/sdk/amxxmodule.cpp @@ -0,0 +1,3119 @@ +/* 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, + MODULE_LIBRARY, + MODULE_LIBCLASS +}; + +// 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; +PFN_SET_TEAM_INFO g_fn_SetTeamInfo; +PFN_PLAYER_PROP_ADDR g_fn_PlayerPropAddr; +PFN_REG_AUTH_FUNC g_fn_RegAuthFunc; +PFN_UNREG_AUTH_FUNC g_fn_UnregAuthFunc; +PFN_FINDLIBRARY g_fn_FindLibrary; +PFN_ADDLIBRARIES g_fn_AddLibraries; +PFN_REMOVELIBRARIES g_fn_RemoveLibraries; +PFN_OVERRIDENATIVES g_fn_OverrideNatives; +PFN_GETLOCALINFO g_fn_GetLocalInfo; + +// *** 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); + REQFUNC("SetPlayerTeamInfo", g_fn_SetTeamInfo, PFN_SET_TEAM_INFO); + REQFUNC("PlayerPropAddr", g_fn_PlayerPropAddr, PFN_PLAYER_PROP_ADDR); + REQFUNC("RegAuthFunc", g_fn_RegAuthFunc, PFN_REG_AUTH_FUNC); + REQFUNC("UnregAuthFunc", g_fn_UnregAuthFunc, PFN_UNREG_AUTH_FUNC); + + REQFUNC("FindLibrary", g_fn_FindLibrary, PFN_FINDLIBRARY); + REQFUNC("AddLibraries", g_fn_AddLibraries, PFN_ADDLIBRARIES); + REQFUNC("RemoveLibraries", g_fn_RemoveLibraries, PFN_REMOVELIBRARIES); + REQFUNC("OverrideNatives", g_fn_OverrideNatives, PFN_OVERRIDENATIVES); + REQFUNC("GetLocalInfo", g_fn_GetLocalInfo, PFN_GETLOCALINFO); + +#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; +} + +C_DLLEXPORT void AMXX_PluginsUnloaded() +{ +#ifdef FN_AMXX_PLUGINSUNLOADED + FN_AMXX_PLUGINSUNLOADED(); +#endif // FN_AMXX_PLUGINSUNLOADED +} + +C_DLLEXPORT void AMXX_PluginsUnloading() +{ +#ifdef FN_AMXX_PLUGINSUNLOADING + FN_AMXX_PLUGINSUNLOADING(); +#endif // FN_AMXX_PLUGINSUNLOADING +} + +// Advanced MF functions +void MF_Log(const char *fmt, ...) +{ + char msg[3072]; + va_list arglst; + va_start(arglst, fmt); + vsnprintf(msg, sizeof(msg) - 1, fmt, arglst); + va_end(arglst); + + g_fn_Log("[%s] %s", MODULE_LOGTAG, msg); +} + +void MF_LogError(AMX *amx, int err, const char *fmt, ...) +{ + char msg[3072]; + va_list arglst; + va_start(arglst, fmt); + vsnprintf(msg, sizeof(msg) - 1, 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, ""); + MF_SetPlayerTeamInfo(0, 0, ""); + MF_PlayerPropAddr(0, 0); + MF_RegAuthFunc(NULL); + MF_UnregAuthFunc(NULL); + MF_FindLibrary(NULL, LibType_Class); + MF_AddLibraries(NULL, LibType_Class, NULL); + MF_RemoveLibraries(NULL); + MF_OverrideNatives(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/hamsandwich/sdk/amxxmodule.h b/dlls/hamsandwich/sdk/amxxmodule.h new file mode 100644 index 00000000..33e1d9c0 --- /dev/null +++ b/dlls/hamsandwich/sdk/amxxmodule.h @@ -0,0 +1,2454 @@ +/* + * 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 __attribute__((visibility("default"))) +#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) +// 4 - added new 'library' setting for direct loading +#define AMXX_INTERFACE_VERSION 4 + +// 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 + const char *library; // added in version 4 + const char *libclass; // added in version 4 +}; + +// 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" */ + + #if _MSC_VER >= 1400 + #if !defined NO_MSVC8_AUTO_COMPAT + + /* Disable deprecation warnings concerning unsafe CRT functions */ + #if !defined _CRT_SECURE_NO_DEPRECATE + #define _CRT_SECURE_NO_DEPRECATE + #endif + + /* Replace the POSIX function with ISO C++ conformant ones as they are now deprecated */ + #define access _access + #define cabs _cabs + #define cgets _cgets + #define chdir _chdir + #define chmod _chmod + #define chsize _chsize + #define close _close + #define cprintf _cprintf + #define cputs _cputts + #define creat _creat + #define cscanf _cscanf + #define cwait _cwait + #define dup _dup + #define dup2 _dup2 + #define ecvt _ecvt + #define eof _eof + #define execl _execl + #define execle _execle + #define execlp _execlp + #define execlpe _execlpe + #define execv _execv + #define execve _execv + #define execvp _execvp + #define execvpe _execvpe + #define fcloseall _fcloseall + #define fcvt _fcvt + #define fdopen _fdopen + #define fgetchar _fgetchar + #define filelength _filelength + #define fileno _fileno + #define flushall _flushall + #define fputchar _fputchar + #define gcvt _gcvt + #define getch _getch + #define getche _getche + #define getcwd _getcwd + #define getpid _getpid + #define getw _getw + #define hypot _hypot + #define inp _inp + #define inpw _inpw + #define isascii __isascii + #define isatty _isatty + #define iscsym __iscsym + #define iscsymf __iscsymf + #define itoa _itoa + #define j0 _j0 + #define j1 _j1 + #define jn _jn + #define kbhit _kbhit + #define lfind _lfind + #define locking _locking + #define lsearch _lsearch + #define lseek _lseek + #define ltoa _ltoa + #define memccpy _memccpy + #define memicmp _memicmp + #define mkdir _mkdir + #define mktemp _mktemp + #define open _open + #define outp _outp + #define outpw _outpw + #define putch _putch + #define putenv _putenv + #define putw _putw + #define read _read + #define rmdir _rmdir + #define rmtmp _rmtmp + #define setmode _setmode + #define sopen _sopen + #define spawnl _spawnl + #define spawnle _spawnle + #define spawnlp _spawnlp + #define spawnlpe _spawnlpe + #define spawnv _spawnv + #define spawnve _spawnve + #define spawnvp _spawnvp + #define spawnvpe _spawnvpe + #define strcmpi _strcmpi + #define strdup _strdup + #define stricmp _stricmp + #define strlwr _strlwr + #define strnicmp _strnicmp + #define strnset _strnset + #define strrev _strrev + #define strset _strset + #define strupr _strupr + #define swab _swab + #define tell _tell + #define tempnam _tempnam + #define toascii __toascii + #define tzset _tzset + #define ultoa _ultoa + #define umask _umask + #define ungetch _ungetch + #define unlink _unlink + #define wcsdup _wcsdup + #define wcsicmp _wcsicmp + #define wcsicoll _wcsicoll + #define wcslwr _wcslwr + #define wcsnicmp _wcsnicmp + #define wcsnset _wcsnset + #define wcsrev _wcsrev + #define wcsset _wcsset + #define wcsupr _wcsupr + #define write _write + #define y0 _y0 + #define y1 _y1 + #define yn _yn + + /* Disable deprecation warnings because MSVC8 seemingly thinks the ISO C++ conformant + * functions above are deprecated. */ + #pragma warning (disable:4996) + + #endif + #else + #define vsnprintf _vsnprintf + #endif +#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 + +#ifdef FN_AMXX_PLUGINSUNLOADING +void FN_AMXX_PLUGINSUNLOADING(void); +#endif // FN_AMXX_PLUGINSUNLOADING + +#ifdef FN_AMXX_PLUGINSUNLOADED +void FN_AMXX_PLUGINSUNLOADED(void); +#endif // FN_AMXX_PLUGINSUNLOADED + +// *** 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. +}; + +enum PlayerProp +{ + Player_Name, //String + Player_Ip, //String + Player_Team, //String + Player_Ingame, //bool + Player_Authorized, //bool + Player_Vgui, //bool + Player_Time, //float + Player_Playtime, //float + Player_MenuExpire, //float + Player_Weapons, //struct{int,int}[32] + Player_CurrentWeapon, //int + Player_TeamID, //int + Player_Deaths, //int + Player_Aiming, //int + Player_Menu, //int + Player_Keys, //int + Player_Flags, //int[32] + Player_Newmenu, //int + Player_NewmenuPage, //int +}; + +enum LibType +{ + LibType_Library, + LibType_Class +}; + +typedef void (*AUTHORIZEFUNC)(int player, const char *authstring); + +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 +typedef void * (*PFN_PLAYER_PROP_ADDR) (int /*id*/, int /*prop*/); + +#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*/); +typedef int (*PFN_SET_TEAM_INFO) (int /*player */, int /*teamid */, const char * /*name */); +typedef void (*PFN_REG_AUTH_FUNC) (AUTHORIZEFUNC); +typedef void (*PFN_UNREG_AUTH_FUNC) (AUTHORIZEFUNC); +typedef int (*PFN_FINDLIBRARY) (const char * /*name*/, LibType /*type*/); +typedef size_t (*PFN_ADDLIBRARIES) (const char * /*name*/, LibType /*type*/, void * /*parent*/); +typedef size_t (*PFN_REMOVELIBRARIES) (void * /*parent*/); +typedef void (*PFN_OVERRIDENATIVES) (AMX_NATIVE_INFO * /*natives*/, const char * /*myname*/); +typedef const char * (*PFN_GETLOCALINFO) (const char * /*name*/, const char * /*def*/); +typedef int (*PFN_AMX_REREGISTER) (AMX * /*amx*/, AMX_NATIVE_INFO * /*list*/, int /*list*/); +typedef void * (*PFN_REGISTERFUNCTIONEX) (void * /*pfn*/, const char * /*desc*/); + +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; +extern PFN_SET_TEAM_INFO g_fn_SetTeamInfo; +extern PFN_PLAYER_PROP_ADDR g_fn_PlayerPropAddr; +extern PFN_REG_AUTH_FUNC g_fn_RegAuthFunc; +extern PFN_UNREG_AUTH_FUNC g_fn_UnregAuthFunc; +extern PFN_FINDLIBRARY g_fn_FindLibrary; +extern PFN_ADDLIBRARIES g_fn_AddLibraries; +extern PFN_REMOVELIBRARIES g_fn_RemoveLibraries; +extern PFN_OVERRIDENATIVES g_fn_OverrideNatives; +extern PFN_GETLOCALINFO g_fn_GetLocalInfo; +extern PFN_AMX_REREGISTER g_fn_AmxReRegister; +extern PFN_REGISTERFUNCTIONEX g_fn_RegisterFunctionEx; + +#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) { } +int MF_SetPlayerTeamInfo (int id, int teamid, const char *teamname) { } +void * MF_PlayerPropAddr (int id, int prop) { } +void MF_RegAuthFunc (AUTHORIZEFUNC fn) { } +void MF_UnregAuthFunc (AUTHORIZEFUNC fn) { } +int MF_FindLibrary (const char *name, LibType type) { } +size_t MF_AddLibraries (const char *name, LibType type, void *parent) { } +size_t MF_RemoveLibraries (void *parent) { } +void MF_OverrideNatives (AMX_NATIVE_INFO *natives, const char *myname) { } +const char * MF_GetLocalInfo (const char *name, const char *def) { } +int MF_AmxReRegister (AMX *amx, AMX_NATIVE_INFO *list, int number) { return 0; } +void * MF_RegisterFunctionEx (void *pfn, const char *description) { } +#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 +#define MF_SetPlayerTeamInfo g_fn_SetTeamInfo +#define MF_PlayerPropAddr g_fn_PlayerPropAddr +#define MF_RegAuthFunc g_fn_RegAuthFunc +#define MF_UnregAuthFunc g_fn_UnregAuthFunc +#define MF_FindLibrary g_fn_FindLibrary +#define MF_AddLibraries g_fn_AddLibraries +#define MF_RemoveLibraries g_fn_RemoveLibraries +#define MF_OverrideNatives g_fn_OverrideNatives +#define MF_GetLocalInfo g_fn_GetLocalInfo +#define MF_AmxReRegister g_fn_AmxReRegister +#define MF_RegisterFunctionEx g_fn_RegisterFunctionEx + +#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/hamsandwich/sdk/moduleconfig.h b/dlls/hamsandwich/sdk/moduleconfig.h new file mode 100644 index 00000000..b5b044d9 --- /dev/null +++ b/dlls/hamsandwich/sdk/moduleconfig.h @@ -0,0 +1,494 @@ +// Configuration + +#ifndef __MODULECONFIG_H__ +#define __MODULECONFIG_H__ + +//#include "svn_version.h" + +// Module info +#define MODULE_NAME "Ham Sandwich" +#define MODULE_VERSION "1.8" +#define MODULE_AUTHOR "AMX Mod X Dev Team" +#define MODULE_URL "http://www.amxmodx.org" +#define MODULE_LOGTAG "HAMSANDWICH" +#define MODULE_LIBRARY "hamsandwich" +#define MODULE_LIBCLASS "" +// 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 + +// use memory manager/tester? +// note that if you use this, you cannot construct/allocate +// anything before the module attached (OnAmxxAttach). +// be careful of default constructors using new/malloc! +// #define MEMORY_TEST + +// Unless you use STL or exceptions, keep this commented. +// It allows you to compile without libstdc++.so as a dependency +// #define NO_ALLOC_OVERRIDES + +// Uncomment this if you are using MSVC8 or greater and want to fix some of the compatibility issues yourself +// #define NO_MSVC8_AUTO_COMPAT + +/** + * 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 Detach (unload) */ +//#define FN_AMXX_DETACH OnAmxxDetach + +/** All plugins loaded + * Do forward functions init here (MF_RegisterForward) + */ +#define FN_AMXX_PLUGINSLOADED OnPluginsLoaded + +/** All plugins are about to be unloaded */ +//#define FN_AMXX_PLUGINSUNLOADING OnPluginsUnloading + +/** All plugins are now unloaded */ +//#define FN_AMXX_PLUGINSUNLOADED OnPluginsUnloaded + + +/**** 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 detach +//#define FN_META_DETACH OnMetaDetach + +// (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 FMH_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/hamsandwich/srvcmd.cpp b/dlls/hamsandwich/srvcmd.cpp new file mode 100644 index 00000000..bd75d7c6 --- /dev/null +++ b/dlls/hamsandwich/srvcmd.cpp @@ -0,0 +1,100 @@ +#include "sdk/amxxmodule.h" + +#include + +#include "CVector.h" + +#include "ham_const.h" +#include "hooklist.h" +#include "offsets.h" +#include "forward.h" +#include "hook.h" + + +extern hook_t hooklist[]; +extern CVector hooks[HAM_LAST_ENTRY_DONT_USE_ME_LOL]; + +void print_srvconsole(char *fmt, ...) +{ + va_list argptr; + static char string[384]; + va_start(argptr, fmt); + vsnprintf(string, sizeof(string) - 1, fmt, argptr); + string[sizeof(string) - 1] = '\0'; + va_end(argptr); + + SERVER_PRINT(string); +} + + + +void HamCommand(void) +{ + const char *cmd=CMD_ARGV(1); + + if (strcmp(cmd, "list")==0) + { + unsigned int Total=0; + print_srvconsole("%-24s | %3s | %10s\n","Name","Set","Value"); + print_srvconsole("-------------------------------------------\n"); + print_srvconsole("%-24s | %s | %10d\n", "pev", Offsets.IsPevSet() == 0 ? "n" : "y", Offsets.GetPev()); + print_srvconsole("%-24s | %s | %10d\n", "base", Offsets.IsBaseSet() == 0 ? "n" : "y", Offsets.GetBase()); + int count=0; + for (int i=0; i= 5) + { + count = 0; + print_srvconsole("-------------------------------------------\n"); + + } + + + } + print_srvconsole("\n%u keys, %u set.\n\n", HAM_LAST_ENTRY_DONT_USE_ME_LOL, Total); + return; + } + else if (strcmp(cmd, "hooks")==0) + { + print_srvconsole("%-24s | %-32s | %10s | %10s\n", "Key", "Classname", "Pre", "Post"); + print_srvconsole("-------------------------------------------------------------------------------------\n"); + unsigned int ForwardCount=0; + unsigned int HookCount=0; + int count = 0; + for (int i=0; i::iterator end=hooks[i].end(); + + for (CVector::iterator j=hooks[i].begin(); + j!=end; + ++j) + { + HookCount++; + ForwardCount+=(*j)->pre.size() + (*j)->post.size(); + + print_srvconsole("%-24s | %-32s | %10d | %10d\n",hooklist[i].name, (*j)->ent, (*j)->pre.size(), (*j)->post.size()); + if (count >= 5) + { + print_srvconsole("-------------------------------------------------------------------------------------\n"); + } + } + } + print_srvconsole("\n%u active hooks, %u active forwards.\n\n", HookCount, ForwardCount); + return; + } + + // Unknown command + print_srvconsole("Usage: ham < command > [ argument ]\n"); + print_srvconsole("Commands:\n"); + print_srvconsole(" %-22s - %s\n", "list", "list all keys and their values from the config file."); + print_srvconsole(" %-22s - %s\n", "hooks", "list all active hooks"); +} + diff --git a/dlls/hamsandwich/typetocell.h b/dlls/hamsandwich/typetocell.h new file mode 100644 index 00000000..5087ed64 --- /dev/null +++ b/dlls/hamsandwich/typetocell.h @@ -0,0 +1,61 @@ +#ifndef TYPETOCELL_H +#define TYPETOCELL_H + +#include +#include "sdk/amxxmodule.h" + +#include "CVector.h" + +#include "hook.h" +#include "forward.h" + +#include "ham_const.h" +#include "ham_utils.h" + + + +inline cell TypeToCell(const float& value) +{ + return amx_ftoc2(value); +} +inline cell TypeToCell(const float*& value) +{ + return amx_ftoc2(*value); +} + +inline cell TypeToCell(const Vector*& value) +{ + return reinterpret_cast(value); +} +inline cell TypeToCell(const int& value) +{ + return value; +} + +inline cell TypeToCell(const edict_t*& value) +{ + if (value == NULL) + { + return -1; + } + + return ENTINDEX_NEW(value); +} + +inline cell TypeToCell(const entvars_t*& value) +{ + if (value == NULL) + { + return -1; + } + + return ENTINDEX_NEW(value->pContainingEntity); +} + +inline cell TypeToCell(const HLBaseEntity*& value) +{ + return PrivateToIndex(reinterpret_cast(value)); +} + + +#endif