diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..5e0c49c
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,70 @@
+#(C)2004-2005 AMX Mod X Development Team
+# Makefile written by David "BAILOPAN" Anderson
+
+HLSDK = sdk/hlsdk
+METAMOD = sdk/metamod
+M_INCLUDE = include
+
+OPT_FLAGS = -O2 -funroll-loops -s -pipe -fomit-frame-pointer -fno-strict-aliasing
+DEBUG_FLAGS = -g -ggdb3
+CPP = g++
+NAME = localizebugfix
+
+BIN_SUFFIX_32 = mm_i386.so
+BIN_SUFFIX_64 = mm_amd64.so
+
+OBJECTS = main.cpp memory.cpp meta_api.cpp
+
+LINK = 
+
+INCLUDE = -I. -I$(M_INCLUDE)/ -I$(HLSDK)/common -I$(HLSDK)/dlls -I$(HLSDK)/engine -I$(HLSDK)/pm_shared -I$(METAMOD)
+
+GCC_VERSION := $(shell $(CPP) -dumpversion >&1 | cut -b1)
+
+ifeq "$(GCC_VERSION)" "4"
+	OPT_FLAGS += -fvisibility=hidden -fvisibility-inlines-hidden
+endif
+
+ifeq "$(DEBUG)" "true"
+	BIN_DIR = Debug
+	CFLAGS = $(DEBUG_FLAGS)
+else
+	BIN_DIR = Release
+	CFLAGS = $(OPT_FLAGS)
+endif
+
+CFLAGS += -DNDEBUG -Wall -Wno-char-subscripts -Wno-unknown-pragmas -Wno-write-strings -Wno-deprecated -Wno-non-virtual-dtor -fno-exceptions -DHAVE_STDINT_H -fno-rtti -static-libgcc -m32
+
+ifeq "$(AMD64)" "true"
+	BINARY = $(NAME)_$(BIN_SUFFIX_64)
+	CFLAGS += -DPAWN_CELL_SIZE=64 -DHAVE_I64 -m64 
+else
+	BINARY = $(NAME)_$(BIN_SUFFIX_32)
+	CFLAGS += -DPAWN_CELL_SIZE=32 -DJIT -DASM32
+	OPT_FLAGS += -march=i586
+endif
+
+OBJ_LINUX := $(OBJECTS:%.cpp=$(BIN_DIR)/%.o)
+
+$(BIN_DIR)/%.o: %.cpp
+	$(CPP) $(INCLUDE) $(CFLAGS) -o $@ -c $<
+
+all:
+	mkdir -p $(BIN_DIR)
+	$(MAKE) $(NAME)
+
+amd64:
+	$(MAKE) all AMD64=true
+
+$(NAME): $(OBJ_LINUX)
+	$(CPP) $(INCLUDE) $(CFLAGS) $(OBJ_LINUX) $(LINK) -shared -ldl -lm -o$(BIN_DIR)/$(BINARY)
+
+debug:	
+	$(MAKE) all DEBUG=true
+
+default: all
+
+clean:
+	rm -rf $(BIN_DIR)/*.o
+	rm -rf $(BIN_DIR)/$(NAME)_$(BIN_SUFFIX_32)
+	rm -rf $(BIN_DIR)/$(NAME)_$(BIN_SUFFIX_64)
diff --git a/README.md b/README.md
index 07c42ee..afc2a29 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,3 @@
-localizebugfix
-==============
-
-Fix localization strings in nickname and chat
+#localizebugfix
+
+Fix localization strings in nickname and chat
diff --git a/bin/2.0/localizebugfix.dll b/bin/2.0/localizebugfix.dll
new file mode 100644
index 0000000..505bc9f
Binary files /dev/null and b/bin/2.0/localizebugfix.dll differ
diff --git a/bin/2.0/localizebugfix.pdb b/bin/2.0/localizebugfix.pdb
new file mode 100644
index 0000000..6766a24
Binary files /dev/null and b/bin/2.0/localizebugfix.pdb differ
diff --git a/bin/2.0/localizebugfix_mm_i386.so b/bin/2.0/localizebugfix_mm_i386.so
new file mode 100644
index 0000000..8dec3f8
Binary files /dev/null and b/bin/2.0/localizebugfix_mm_i386.so differ
diff --git a/bin/2.3/localizebugfix.dll b/bin/2.3/localizebugfix.dll
new file mode 100644
index 0000000..ad4472d
Binary files /dev/null and b/bin/2.3/localizebugfix.dll differ
diff --git a/bin/2.3/localizebugfix.pdb b/bin/2.3/localizebugfix.pdb
new file mode 100644
index 0000000..3f0d812
Binary files /dev/null and b/bin/2.3/localizebugfix.pdb differ
diff --git a/bin/2.3/localizebugfix_2_3.7z b/bin/2.3/localizebugfix_2_3.7z
new file mode 100644
index 0000000..8172649
Binary files /dev/null and b/bin/2.3/localizebugfix_2_3.7z differ
diff --git a/bin/2.3/localizebugfix_mm_i386.so b/bin/2.3/localizebugfix_mm_i386.so
new file mode 100644
index 0000000..3acd4ec
Binary files /dev/null and b/bin/2.3/localizebugfix_mm_i386.so differ
diff --git a/include/CVector.h b/include/CVector.h
new file mode 100644
index 0000000..1d733ab
--- /dev/null
+++ b/include/CVector.h
@@ -0,0 +1,502 @@
+/* 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 <assert.h>
+
+// Vector
+template <class T> class CVector
+{
+	bool Grow(size_t amount)
+	{
+		// automatic grow
+		size_t newSize = m_Size * 2;
+
+		if (newSize == 0)
+		{
+			newSize = 8;
+		}
+
+		while (m_CurrentUsedSize + amount > newSize)
+		{
+			newSize *= 2;
+		}
+		T *newData = new T[newSize];
+		if (!newData)
+			return false;
+		if (m_Data)
+		{
+			for (size_t i=0; i<m_CurrentUsedSize; i++)
+				newData[i] = m_Data[i];
+			delete [] m_Data;
+		}
+		m_Data = newData;
+		m_Size = newSize;
+		return true;
+	}
+
+	bool GrowIfNeeded(size_t amount)
+	{
+		if (m_CurrentUsedSize + amount >= m_Size)
+		{
+			return Grow(amount);
+		}
+		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<end; i++)
+				newData[i] = m_Data[i];
+			delete [] m_Data;
+		}
+		m_Data = newData;
+		m_Size = size;
+		if (m_CurrentUsedSize > 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<T>()
+	{
+		m_Size = 0;
+		m_CurrentUsedSize = 0;
+		m_Data = NULL;
+	}
+
+	CVector<T>(const CVector<T> & 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<other.m_CurrentUsedSize; i++)
+			m_Data[i] = other.m_Data[i];
+	}
+
+	~CVector<T>()
+	{
+		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)
+	{
+		if (!GrowIfNeeded(1))
+		{
+			return false;
+		}
+
+		m_Data[m_CurrentUsedSize++] = 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();
+
+		if (!GrowIfNeeded(1))
+		{
+			return false;
+		}
+
+		++m_CurrentUsedSize;
+
+		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/include/main.h b/include/main.h
new file mode 100644
index 0000000..71d67a0
--- /dev/null
+++ b/include/main.h
@@ -0,0 +1,128 @@
+/*
+ * Localize Bug Fix
+ * Copyright (c) 2013 - 2014 AGHL.RU Dev Team
+ * 
+ * http://aghl.ru/forum/ - Russian Half-Life and Adrenaline Gamer Community
+ *
+ *
+ *    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 _MAIN_H_
+#define _MAIN_H_
+
+#include "memory.h"
+#include "CVector.h"
+
+#include "extdll.h"
+#include "meta_api.h"
+
+#define MAX_CLIENTS 32
+
+#ifdef _WIN32
+	#define SIZEOF_CLIENT_T 20504
+	#define PLAYER_NAME_OFFSET 19720
+#else
+	#define SIZEOF_CLIENT_T 20212
+	#define PLAYER_NAME_OFFSET 19432
+#endif
+
+typedef struct server_static_s
+{
+	int initialized;
+	int clients;
+	int maxclients;
+	//[..]
+} server_static_t;
+
+const char *szLocalizeBuffer[] =
+{
+	"#GameUI_DetailTextures",
+	"#Team_Select","#Team_Select_Spect","#IG_Team_Select","#IG_Team_Select_Spect","#IG_VIP_Team_Select","#IG_VIP_Team_Select_Spect","#Terrorist_Select",
+	"#CT_Select","#Buy","#CT_BuyItem","#T_BuyItem","#DCT_BuyItem","#DT_BuyItem","#CT_BuyPistol","#T_BuyPistol","#AS_BuyShotgun","#BuyShotgun","#CT_BuySubMachineGun",
+	"#T_BuySubMachineGun","#AS_CT_BuySubMachineGun","#AS_T_BuySubMachineGun","#T_BuyRifle","#CT_BuyRifle","#AS_T_BuyRifle","#AS_CT_BuyRifle","#AS_T_BuyMachineGun",
+	"#BuyMachineGun","#RadioA","#RadioB","#RadioC","#AK47","#SG552","#M4A1","#Famas","#Galil","#Aug","#Scout","#ArcticWarfareMagnum","#G3SG1","#SG550","#USP45","#Glock18",
+	"#DesertEagle","#P228","#Beretta96G","#FiveSeven","#Super90","#XM1014","#mp5navy","#tmp","#FNP90","#Mac10","#UMP45","#M249","#Krieg552","#M4A1_Short","#Schmidt","#Magnum",
+	"#D3AU1","#Krieg550","#KM45Tactical","#Sidearm9X19mm","#NightHawk","#P228Compact","#Dual40","#ESFiveSeven","#Leone12","#AutoShotgun","#SubMachineGun","#SchmidtMP","#ESC90",
+	"#Mac10_Short","#KMUMP45","#ESM249","#TEAMS","#PLAYERS","#CLASS","#SCORE","#DEATHS","#LATENCY","#VOICE","#Menu_OK","#Menu_Cancel","#Menu_Spectate","#Team_AutoAssign",
+	"#Title_SelectYourTeam","#Target_Bombed","#VIP_Escaped","#VIP_Assassinated","#Terrorists_Escaped","#CTs_PreventEscape","#Escaping_Terrorists_Neutralized","#Bomb_Defused",
+	"#CTs_Win","#Terrorists_Win","#Round_Draw","#All_Hostages_Rescued","#Target_Saved","#Hostages_Not_Rescued","#Terrorists_Not_Escaped","#VIP_Not_Escaped","#Cannot_Buy_This",
+	"#Not_Enough_Money","#Weapon_Not_Available","#Already_Have_Kevlar","#Already_Have_Kevlar_Helmet","#Already_Have_Kevlar_Bought_Helmet","#Cannot_Carry_Anymore","#Already_Have_One",
+	"#Cannot_Switch_From_VIP","#All_Teams_Full","#Terrorists_Full","#CTs_Full","#Too_Many_Terrorists","#Too_Many_CTs","#Wait_3_Seconds","#Only_1_Team_Change","#Ignore_Broadcast_Messages",
+	"#Ignore_Broadcast_Team_Messages","#Accept_All_Messages","#Ignore_Radio","#Accept_Radio","#Command_Not_Available","#Defusing_Bomb_With_Defuse_Kit",
+	"#Defusing_Bomb_Without_Defuse_Kit","#Killed_Hostage","#Injured_Hostage","#Auto_Team_Balance_Next_Round","#All_VIP_Slots_Full","#Killed_Teammate",
+	"#Banned_For_Killing_Teammates","#Cannot_Vote_Map","#Weapon_Cannot_Be_Dropped","#Terrorist_Escaped","#C4_Plant_At_Bomb_Spot","#C4_Plant_Must_Be_On_Ground",
+	"#C4_Arming_Cancelled","#Bomb_Planted","#C4_Activated_At_Bomb_Spot","#Switch_To_BurstFire","#Switch_To_SemiAuto","#Switch_To_FullAuto","#TRAINING1","#TRAINING2","#TRAINING3",
+	"#TRAINING4","#TRAINING5","#TRAINING6","#TRAINING7","#GAMESAVED","#Game_Commencing","#Game_connected","#Game_disconnected","#Game_join_terrorist","#Game_join_ct",
+	"#Game_join_terrorist_auto","#Game_join_ct_auto","#Game_scoring","#Game_idle_kick","#Game_bomb_drop","#Game_bomb_pickup","#Game_no_timelimit","#Game_timelimit",
+	"#Game_unknown_command","#Game_in_position","#Game_added_position","#Game_teammate_kills","#Game_required_votes","#Game_radio","#Game_teammate_attack","#Game_kicked",
+	"#Game_vote_cast","#Game_vote_usage","#Game_vote_player_not_found","#Game_vote_players_on_your_team","#Game_vote_not_yourself","#Game_voted_for_map","#Game_votemap_usage",
+	"#Cannot_Vote_Need_More_People","#Map_Vote_Extend","#Cannot_Vote_With_Less_Than_Three","#Game_will_restart_in","#Game_will_restart_in_console","#Cover_me","#You_take_the_point",
+	"#Hold_this_position","#Regroup_team","#Follow_me","#Taking_fire","#Go_go_go","#Team_fall_back","#Stick_together_team","#Get_in_position_and_wait","#Storm_the_front","#Report_in_team",
+	"#Affirmative","#Roger_that","#Enemy_spotted","#Need_backup","#Sector_clear","#In_position","#Reporting_in","#Get_out_of_there","#Negative","#Enemy_down","#Hostage_down",
+	"#Fire_in_the_hole","#Cant_buy","#VIP_cant_buy","#CT_cant_buy","#Terrorist_cant_buy","#Vote","#Votes","#Hint_press_buy_to_purchase","#Hint_use_nightvision","#Hint_lost_money",
+	"#Hint_removed_for_next_hostage_killed","#Hint_careful_around_hostages","#Hint_careful_around_teammates","#Hint_reward_for_killing_vip","#Hint_win_round_by_killing_enemy",
+	"#Hint_try_not_to_injure_teammates","#Hint_you_are_in_targetzone","#Hint_hostage_rescue_zone","#Hint_terrorist_escape_zone","#Hint_ct_vip_zone","#Hint_terrorist_vip_zone",
+	"#Hint_cannot_play_because_tk","#Hint_use_hostage_to_stop_him","#Hint_lead_hostage_to_rescue_point","#Hint_you_have_the_bomb","#Hint_you_are_the_vip","#Hint_out_of_ammo",
+	"#Hint_spotted_a_friend","#Hint_spotted_an_enemy","#Hint_prevent_hostage_rescue","#Hint_rescue_the_hostages","#Hint_press_use_so_hostage_will_follow","#Friend","#Enemy","#Hostage",
+	"#Health","#Map_descr_not_avail","#Class_descr_not_avail","#Title_terrorist_model_selection","#Phoenix_Connexion","#L337_Krew","#Arctic_Avengers","#Guerilla_Warfare","#Auto_Select",
+	"#Title_ct_model_selection","#Seal_Team_6","#Title_seal_team","#GSG_9","#Title_gsg9","#SAS","#Title_sas","#GIGN","#Title_gign","#Title_select_category_of_purchase",
+	"#Title_equipment_selection","#Kevlar","#Kevlar_Vest","#Kevlar_Helmet","#Kevlar_Vest_Ballistic_Helmet","#Flashbang","#HE_Grenade","#High_Explosive_Grenade","#Smoke_Grenade",
+	"#Defusal_Kit","#Bomb_Defusal_Kit","#NightVision","#Nightvision_Goggles","#TactShield","#TactShield_Desc","#Title_pistol_selection","#Pistols","#Buy_pistols",
+	"#Title_shotgun_selection","#Shotguns","#Buy_shotguns","#Title_smg_selection","#SMGs","#Buy_smgs","#Title_rifle_selection","#Rifles","#Buy_rifles","#Title_machinegun_selection",
+	"#MachineGuns","#Buy_machineguns","#Prim_Ammo","#Buy_prim_ammo","#Sec_Ammo","#Buy_sec_ammo","#Equipment","#Buy_equipment","#Terrorist_Forces","#CT_Forces","#VIP","#WINS","#BOMB","#DEAD",
+	"#SCORES","#Player","#Player_plural","#Got_defuser","#Got_bomb","#Mic_Volume","#Speaker_Volume","#Voice_Properties","#Cannot_Be_Spectator","#Map_Description_not_available","#Muted",
+	"#Unmuted","#No_longer_hear_that_player","#OBS_NONE","#OBS_CHASE_LOCKED","#OBS_CHASE_FREE","#OBS_ROAMING","#OBS_IN_EYE","#OBS_MAP_FREE","#OBS_MAP_CHASE","#SPECT_OPTIONS","#CAM_OPTIONS",
+	"#Name_change_at_respawn","#C4_Defuse_Must_Be_On_Ground","#Spec_Mode1","#Spec_Mode2","#Spec_Mode3","#Spec_Mode4","#Spec_Mode5","#Spec_Mode6","#Spec_NoTarget","#Spec_Help_Title",
+	"#Spec_Help_Text","#Spec_Slow_Motion","#Spec_Replay","#Spec_Auto","#Spec_Time","#Spec_Map","#Spectators","#Unassigned","#Only_CT_Can_Move_Hostages","#Spec_Duck",
+	"#Spec_Not_Valid_Choice","#Spec_Not_In_Spectator_Mode","#Spec_NoPlayers","#Spec_ListPlayers","#Selection_Not_Available","#Alias_Not_Avail","#Spec_No_PIP"
+};
+
+extern DLL_FUNCTIONS *g_pFunctionTable;
+
+static server_static_t *global_svs;
+
+static CVector<const char *> localize;
+
+static int localize_string(char *buf,bool apersand);
+
+static void (*pfnCmd_TokenizeString)(char *buf);
+
+static inline void localize_push()
+{
+	int j = (sizeof(szLocalizeBuffer) / sizeof(szLocalizeBuffer[0]));
+
+	for(int i = 0; i < j; i++)
+		localize.push_back(szLocalizeBuffer[i]);
+};
+static inline char *getClientName(edict_t *pEdict)
+{
+	unsigned int p = ENTINDEX(pEdict) - 1;
+	return (char *)(global_svs->clients + p * SIZEOF_CLIENT_T + PLAYER_NAME_OFFSET);
+}
+
+#endif //_MAIN_H_
+
diff --git a/include/memory.h b/include/memory.h
new file mode 100644
index 0000000..095278a
--- /dev/null
+++ b/include/memory.h
@@ -0,0 +1,85 @@
+/*
+ * Localize Bug Fix
+ * Copyright (c) 2013 - 2014 AGHL.RU Dev Team
+ * 
+ * http://aghl.ru/forum/ - Russian Half-Life and Adrenaline Gamer Community
+ *
+ *
+ *    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 _MEMORY_H_
+#define _MEMORY_H_
+
+#ifdef _WIN32
+	#include <windows.h>
+	#include <psapi.h>
+#ifdef _MSC_VER <= 1600
+	#define PSAPI_VERSION 1
+#endif
+#else
+	#include <dlfcn.h>
+	#include <unistd.h>
+	#include <sys/types.h>
+	#include <sys/stat.h>
+	#include <sys/mman.h>
+	#include <string.h>
+	#include <link.h>
+	
+	#define Align(addr)	((void *)(((long)addr) & ~(sysconf(_SC_PAGESIZE) - 1)))
+#endif
+
+#ifdef _MSC_VER
+	#pragma comment(lib,"psapi.lib")
+#endif
+
+#ifndef dword
+	#define dword unsigned long
+#endif
+
+struct lib_t
+{
+	char *base;
+	void *handle;
+	dword size;
+};
+
+int lib_load_info(void *addr,lib_t *lib);
+
+char *lib_find_pattern(lib_t *lib,const char *pattern,int len);
+char *lib_find_pattern_fstr(lib_t *lib,const char *string,int range,const char *pattern,int len);
+
+char *mem_find_ref(char *start,int range,int opcode,dword ref,int relative);
+char *mem_find_pattern(char *pos,int range,const char *pattern,int len);
+
+int mem_change_protection(void *addr,const char *patch,int len);
+
+#ifndef _WIN32
+char *lib_find_symbol(lib_t *lib,const char *symbol);
+#endif
+
+#endif //_MEMORY_H_
+
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..bd9c81e
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,251 @@
+/*
+ * Localize Bug Fix
+ * Copyright (c) 2013 - 2014 AGHL.RU Dev Team
+ * 
+ * http://aghl.ru/forum/ - Russian Half-Life and Adrenaline Gamer Community
+ *
+ *
+ *    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.
+ *
+ */
+
+#include "main.h"
+
+void Cmd_TokenizeString_Handler(char *buf)
+{
+	if(!strncmp(buf,"say ",4) || !strncmp(buf,"say_team ",9))
+	{
+		localize_string(buf,true);
+	}
+	pfnCmd_TokenizeString(buf);
+}
+void OnMetaAttach()
+{
+	lib_t lib;
+
+	char *addr;
+	char patch[4];
+
+#ifdef _WIN32
+	char p1[] = "\x55\x8B\x2A\xA1\x2A\x2A\x2A\x2A\x56\x33\x2A\x85\x2A\x7E\x2A\x8B\x2A\x2A\x2A\x2A\x2A\x2A\x50";
+	char p2[] = "\x56\xE8\x2A\x2A\x2A\x2A\xA1\x2A\x2A\x2A\x2A\x50\xFF\x2A\x2A\x2A\x2A\x2A\x83\x2A\x2A\x5E\xC3";
+#endif
+
+	lib_load_info((void *)gpGlobals,&lib);
+
+#ifdef _WIN32
+	// * Cmd_TokenizeString | addr - 049A3FC0
+	addr = lib_find_pattern(&lib,p1,sizeof(p1) - 1);//23
+#else
+	addr = lib_find_symbol(&lib,"Cmd_TokenizeString");
+#endif
+	if(!addr)
+	{
+		LOG_ERROR(PLID,"can't find \"Cmd_TokenizeString\"");
+		return;
+	}
+
+	pfnCmd_TokenizeString = reinterpret_cast<void (*)(char *)>(addr);
+
+#ifdef _WIN32
+	// * SV_ParseStringCommand | addr - 01DAB0AF
+	addr = lib_find_pattern(&lib,p2,sizeof(p2) - 1);
+
+	if(!addr)
+	{
+		LOG_ERROR(PLID,"can't find \"Cmd_TokenizeString\" inside function \"SV_ParseStringCommand\"");
+		return;
+	}
+	// 01DAB0D8 56                       push    esi
+	// 01DAB0D9 E8 E2 8E F8 FF			call    Cmd_TokenizeString
+
+	addr += 2;// 01DAB0D8 + 1
+#else
+
+	addr = lib_find_symbol(&lib,"SV_ParseStringCommand");
+
+	if(!addr)
+	{
+		LOG_ERROR(PLID,"can't find \"SV_ParseStringCommand\"");
+		return;
+	}
+
+	// 0009B1B0 53                       push    ebx
+	// 0009B1B1 E8 AA A5 FA FF                      call    Cmd_TokenizeString
+
+	addr = mem_find_ref(addr,200,'\xE8',(dword)pfnCmd_TokenizeString,1);
+
+	if(!addr)
+	{
+		LOG_ERROR(PLID,"can't find \"Cmd_TokenizeString\" inside function \"SV_ParseStringCommand\"");
+		return;
+	}
+
+	addr += 1;
+#endif
+	*(dword *)patch = (dword)Cmd_TokenizeString_Handler - (dword)addr - 4;
+
+	if(!mem_change_protection(addr,patch,sizeof(patch)))
+	{
+		LOG_ERROR(PLID,"patch failed.");
+		return;
+	}
+
+#ifdef _WIN32
+	addr = lib_find_pattern_fstr(&lib,"#      name userid uniqueid frag time ping loss adr\n",-12,"\x68\x2A\x2A\x2A\x2A\x53\x56",7);
+#else
+	addr = lib_find_symbol(&lib,"svs");
+#endif
+
+	if(!addr)
+	{
+		LOG_ERROR(PLID,"can't find \"svs\"");
+		return;
+	}
+
+#ifdef _WIN32
+	addr += 25;
+	global_svs = (struct server_static_s *)(*(dword **)addr - 2);
+#else
+	global_svs = (struct server_static_s *)addr;
+#endif
+
+	localize_push();
+};
+void ClientUserInfoChanged(edict_t *pEdict,char *infobuffer)
+{
+	if(!global_svs)
+		RETURN_META(MRES_IGNORED);
+
+	char c;
+	char *s;
+	char *buf;
+
+	int i = 0;
+	int j = 0;
+
+	s = getClientName(pEdict);
+	buf = INFOKEY_VALUE(infobuffer,"name");
+
+	if(*s != '\0' && !strcmp(s,buf))
+		RETURN_META(MRES_IGNORED);
+
+	if(*s == '#')
+		*s = '*';
+
+	for(;*buf != '\0'; buf++, i++)
+	{
+		if(*buf != '+')
+			continue;
+
+		c = *(buf + 1);
+
+		if(!isspace(c) && (isdigit(c) || isalpha(c)))
+		{
+			*buf = '*';
+			j++;
+		}
+	};
+
+	if(localize_string(buf -= i,false) || j)
+	{
+		SET_CLIENT_KEYVALUE(ENTINDEX(pEdict),infobuffer,"name",buf);
+	}
+	RETURN_META(MRES_IGNORED);
+};
+#ifdef _WIN32
+static char *strcasestr(const char *phaystack,const char *pneedle)
+{
+	const char *a,*b;
+	for(;*phaystack; *phaystack++)
+	{
+		a = phaystack;
+		b = pneedle;
+
+		while((*a++|32) == (*b++|32))
+		{
+			if(!*b)
+				return (char *)phaystack;
+		}
+	}
+	return NULL;
+};
+#endif
+static int localize_string(char *buf,bool apersand)
+{
+	if(*buf == '\0')
+	{
+		return 0;
+	}
+
+	int t = 0;
+	char *j,*a;
+	char *c = buf;
+
+	if(apersand)
+	{
+		do {
+			if(*c == '%')
+				*c = ' ';
+
+			t++;
+
+		} while(*c++);
+
+		c -= t;
+	}
+
+	t = 0;
+
+	while(1)
+	{
+		if(!c || !(j = strstr(c,"#")))
+			break;
+
+		c = j + 1;
+
+		if(!isdigit(*c) && isalpha(*c) && !isspace(*c))
+		{
+			CVector<const char *> *p = &(localize);
+			for(CVector<const char *>::iterator i = p->begin(); i != p->end(); i++)
+			{
+				while(1)
+				{
+					if(!(a = strcasestr(buf,(*i)))
+						&& !(a = strcasestr(buf,"#CZero_"))
+						&& !(a = strcasestr(buf,"#Cstrike_"))
+						&& !(a = strcasestr(buf,"#Career_")))
+					{
+						break;
+					}
+
+					*a = '*';
+					t++;
+				}
+			}
+		}
+	}
+	return (t > 0 && *buf != '\0');
+};
\ No newline at end of file
diff --git a/memory.cpp b/memory.cpp
new file mode 100644
index 0000000..d212f2c
--- /dev/null
+++ b/memory.cpp
@@ -0,0 +1,194 @@
+/*
+ * Localize Bug Fix
+ * Copyright (c) 2013 - 2014 AGHL.RU Dev Team
+ * 
+ * http://aghl.ru/forum/ - Russian Half-Life and Adrenaline Gamer Community
+ *
+ *
+ *    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.
+ *
+ */
+
+#include "memory.h"
+
+#ifdef _WIN32
+int lib_load_info(void *addr,lib_t *lib)
+{
+	MEMORY_BASIC_INFORMATION mem;
+	VirtualQuery(addr,&mem,sizeof(mem));
+
+	IMAGE_DOS_HEADER *dos = (IMAGE_DOS_HEADER*)mem.AllocationBase;
+	IMAGE_NT_HEADERS *pe = (IMAGE_NT_HEADERS*)((dword)dos + (dword)dos->e_lfanew);
+
+	if(pe->Signature != IMAGE_NT_SIGNATURE)
+		return 0;
+
+	lib->base = (char *)mem.AllocationBase;
+	lib->size = (size_t)pe->OptionalHeader.SizeOfImage;
+
+	return 1;
+}
+#else
+char *lib_find_symbol(lib_t *lib,const char *symbol)
+{
+	return (char *)dlsym(lib->handle,symbol);
+}
+static ElfW(Addr) dlsize(void *base)
+{
+	int i;
+	ElfW(Ehdr) *ehdr;
+	ElfW(Phdr) *phdr;
+	ElfW(Addr) end;
+
+	ehdr = (ElfW(Ehdr)*)base;
+	phdr = (ElfW(Phdr)*)((ElfW(Addr))ehdr + ehdr->e_phoff);
+
+	for(i = 0; i < ehdr->e_phnum; ++i)
+	{
+		if(phdr[i].p_type == PT_LOAD)
+			end = phdr[i].p_vaddr + phdr[i].p_memsz;
+	}
+	return end;
+}
+int lib_load_info(void *addr,lib_t *lib)
+{
+	Dl_info info;
+	if(!dladdr(addr,&info) || !info.dli_fbase || !info.dli_fname)
+		return 0;
+
+	lib->base = (char *)info.dli_fbase;
+	lib->size = dlsize(info.dli_fbase);
+	lib->handle = dlopen(info.dli_fname,RTLD_NOW);
+
+	return 1;
+}
+#endif
+static inline int mem_compare_c(const char *addr,const char *pattern,const char *pattern_end)
+{
+	const char *c;
+	for(c = pattern; c < pattern_end; ++c, ++addr)
+	{
+		if(*c == *addr || *c == '\x2A')
+			continue;
+
+		return 0;
+	}
+	return 1;
+}
+static char *mem_find_ref_c(char *pos,char *end,int opcode,dword ref,int relative)
+{
+	for(; pos < end; ++pos)
+	{
+		if(*pos == opcode)
+		{
+			if(relative)
+			{
+				if((dword)pos + 5 + *(dword *)(pos + 1) == ref)
+					return pos;
+			}
+			else
+			{
+				if(*(dword *)(pos + 1) == ref)
+					return pos;
+			}
+		}
+	}
+	return NULL;
+}
+char *mem_find_pattern(char *pos,int range,const char *pattern,int len)
+{
+	char *end;
+	const char *pattern_end;
+	
+	pattern_end = pattern + len;
+
+	for(end = pos + range - len; pos < end; ++pos)
+	{
+		if(mem_compare_c(pos,pattern,pattern_end))
+			return pos;
+	}
+	return NULL;
+}
+static char *lib_find_string_push(lib_t *lib,const char *string)
+{
+	char *addr;
+	addr = mem_find_pattern(lib->base,lib->size,string,strlen(string) + 1);
+	return mem_find_ref_c(lib->base,lib->base + lib->size - 5,'\x68',(dword)addr,0);
+}
+char *mem_find_ref(char *start,int range,int opcode,dword ref,int relative)
+{
+	return mem_find_ref_c(start,start + range - 5,opcode,ref,relative);
+}
+char *lib_find_pattern(lib_t *lib,const char *pattern,int len)
+{
+	return mem_find_pattern(lib->base,lib->size,pattern,len);
+}
+char *lib_find_pattern_fstr(lib_t *lib,const char *string,int range,const char *pattern,int len)
+{
+	char *addr;
+	addr = lib_find_string_push(lib,string);
+
+	if(addr)
+	{
+		if(range < 0)
+		{
+			addr += range;
+			range = -range;
+		}
+		return mem_find_pattern(addr,range,pattern,len);
+	}
+	return NULL;
+}
+int mem_change_protection(void *addr,const char *patch,int len)
+{
+#ifdef _WIN32
+	static HANDLE process = 0;
+	DWORD OldProtection,NewProtection = PAGE_EXECUTE_READWRITE;
+
+	if(!process)
+		process = GetCurrentProcess();
+
+	FlushInstructionCache(process,addr,len);
+	if(VirtualProtect(addr,len,NewProtection,&OldProtection))
+	{
+		memcpy(addr,patch,len);
+		return VirtualProtect(addr,len,OldProtection,&NewProtection);
+	}
+#else
+	size_t size = sysconf(_SC_PAGESIZE);
+	void *alignedAddress = Align(addr);
+
+	if(Align(addr + len - 1) != alignedAddress)
+		size *= 2;
+
+	if(!mprotect(alignedAddress,size,(PROT_READ|PROT_WRITE|PROT_EXEC)))
+	{
+		memcpy(addr,patch,len);
+		return !mprotect(alignedAddress,size,(PROT_READ|PROT_EXEC));
+	}
+#endif
+	return 0;
+}
+
diff --git a/meta_api.cpp b/meta_api.cpp
new file mode 100644
index 0000000..6ef8582
--- /dev/null
+++ b/meta_api.cpp
@@ -0,0 +1,154 @@
+/*
+ * Localize Bug Fix
+ * Copyright (c) 2013 - 2014 AGHL.RU Dev Team
+ * 
+ * http://aghl.ru/forum/ - Russian Half-Life and Adrenaline Gamer Community
+ *
+ *
+ *    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.
+ *
+ */
+
+#include "extdll.h"
+#include "meta_api.h"
+
+#undef C_DLLEXPORT
+
+#ifdef _WIN32
+	#define C_DLLEXPORT extern "C" __declspec(dllexport)
+#else
+	#include <sys/mman.h>
+	#define C_DLLEXPORT extern "C" __attribute__((visibility("default")))
+#endif
+
+plugin_info_t Plugin_info = {
+
+	META_INTERFACE_VERSION,
+	"LocalizeBug Fix",
+	"2.3",
+	"20/09/14",
+	"s1lent",
+	"http://www.aghl.ru/",
+	"LocalizeBug Fix",
+	PT_STARTUP,
+	PT_NEVER,
+};
+
+DLL_FUNCTIONS gpFunctionTable;
+DLL_FUNCTIONS *g_pFunctionTable;
+enginefuncs_t g_engfuncs;
+
+meta_globals_t *gpMetaGlobals;
+gamedll_funcs_t *gpGamedllFuncs;
+mutil_funcs_t *gpMetaUtilFuncs;
+
+globalvars_t *gpGlobals;
+META_FUNCTIONS gMetaFunctionTable;
+
+void OnMetaAttach();
+void ClientCommand(edict_t *pEdict);
+void ClientUserInfoChanged(edict_t *pEdict,char *infobuffer);
+
+C_DLLEXPORT int Meta_Query(char *,plugin_info_t **pPlugInfo,mutil_funcs_t *pMetaUtilFuncs)
+{
+	*pPlugInfo = &(Plugin_info);
+	gpMetaUtilFuncs = pMetaUtilFuncs;
+	return 1;
+}
+C_DLLEXPORT int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable,int *)
+{
+	memset(&gpFunctionTable,0,sizeof(DLL_FUNCTIONS));
+	//gpFunctionTable.pfnClientCommand = ClientCommand;
+	gpFunctionTable.pfnClientUserInfoChanged = ClientUserInfoChanged;
+	memcpy(pFunctionTable,&gpFunctionTable,sizeof(DLL_FUNCTIONS));
+
+	g_pFunctionTable = pFunctionTable;
+	OnMetaAttach();
+
+	return 1;
+}
+C_DLLEXPORT int Meta_Attach(PLUG_LOADTIME now,META_FUNCTIONS *pFunctionTable,meta_globals_t *pMGlobals,gamedll_funcs_t *pGamedllFuncs)
+{
+	if(!pMGlobals || !pFunctionTable)
+		return 0;
+
+	gpMetaGlobals = pMGlobals;
+	gpGamedllFuncs = pGamedllFuncs;
+
+	gMetaFunctionTable.pfnGetEntityAPI2 = GetEntityAPI2;
+	memcpy(pFunctionTable,&gMetaFunctionTable,sizeof(META_FUNCTIONS));
+
+	return 1;
+}
+C_DLLEXPORT int Meta_Detach(PLUG_LOADTIME now,PL_UNLOAD_REASON reason)
+{
+	return 0;
+}
+#ifdef __linux__
+	C_DLLEXPORT void GiveFnptrsToDll(enginefuncs_t *pengfuncsFromEngine,globalvars_t *pGlobals) {
+#else
+	#ifdef _MSC_VER
+	C_DLLEXPORT __declspec(naked) void GiveFnptrsToDll(enginefuncs_t *pengfuncsFromEngine,globalvars_t *pGlobals) {
+		__asm {
+			push ebp
+			mov ebp,esp
+			sub esp,__LOCAL_SIZE
+			push ebx
+			push esi
+			push edi
+		}
+	#else	// _MSC_VER
+		#ifdef __GNUC__
+			C_DLLEXPORT void __stdcall GiveFnptrsToDll(enginefuncs_t *pengfuncsFromEngine,globalvars_t *pGlobals) {
+		#else
+			#error There is no support (yet) for your compiler. Please use MSVC or GCC compilers.
+		#endif
+	#endif // _MSC_VER
+#endif // __linux__
+		memcpy(&g_engfuncs,pengfuncsFromEngine,sizeof(enginefuncs_t));
+		gpGlobals = pGlobals;
+		#ifdef _MSC_VER
+		if(sizeof(int *) == 8) {
+			__asm {
+				pop edi
+				pop esi
+				pop ebx
+				mov esp,ebp
+				pop ebp
+				ret 16
+			}
+		}
+		else {
+			__asm {
+				pop edi
+				pop esi
+				pop ebx
+				mov esp,ebp
+				pop ebp
+				ret 8
+			}
+		}
+	#endif // #ifdef _MSC_VER
+}
diff --git a/msvc10/localizebugfix.sln b/msvc10/localizebugfix.sln
new file mode 100644
index 0000000..af09dbf
--- /dev/null
+++ b/msvc10/localizebugfix.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "localizebugfix", "localizebugfix.vcxproj", "{933B0D94-C6EC-47FB-AE34-2DC9F2B6D851}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{933B0D94-C6EC-47FB-AE34-2DC9F2B6D851}.Debug|Win32.ActiveCfg = Debug|Win32
+		{933B0D94-C6EC-47FB-AE34-2DC9F2B6D851}.Debug|Win32.Build.0 = Debug|Win32
+		{933B0D94-C6EC-47FB-AE34-2DC9F2B6D851}.Release|Win32.ActiveCfg = Release|Win32
+		{933B0D94-C6EC-47FB-AE34-2DC9F2B6D851}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/msvc10/localizebugfix.suo b/msvc10/localizebugfix.suo
new file mode 100644
index 0000000..9eb70fb
Binary files /dev/null and b/msvc10/localizebugfix.suo differ
diff --git a/msvc10/localizebugfix.vcxproj b/msvc10/localizebugfix.vcxproj
new file mode 100644
index 0000000..6707ea1
--- /dev/null
+++ b/msvc10/localizebugfix.vcxproj
@@ -0,0 +1,142 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\main.cpp" />
+    <ClCompile Include="..\memory.cpp" />
+    <ClCompile Include="..\meta_api.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\include\CVector.h" />
+    <ClInclude Include="..\include\main.h" />
+    <ClInclude Include="..\include\memory.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{933B0D94-C6EC-47FB-AE34-2DC9F2B6D851}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>shdetect</RootNamespace>
+    <ProjectName>localizebugfix</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v110</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v100</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>TurnOffAllWarnings</WarningLevel>
+      <Optimization>Full</Optimization>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>include\;sdk\metamod;sdk\hlsdk\common;sdk\hlsdk\engine;sdk\hlsdk\dlls;sdk\hlsdk\pm_shared</AdditionalIncludeDirectories>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+      <DataExecutionPrevention>false</DataExecutionPrevention>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>TurnOffAllWarnings</WarningLevel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <Optimization>Full</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\include\;..\sdk\metamod;..\sdk\hlsdk\common;..\sdk\hlsdk\engine;..\sdk\hlsdk\dlls;..\sdk\hlsdk\pm_shared</AdditionalIncludeDirectories>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <StringPooling>false</StringPooling>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>
+      </PrecompiledHeaderOutputFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>psapi.lib</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+    <Bscmake>
+      <SuppressStartupBanner>false</SuppressStartupBanner>
+    </Bscmake>
+    <PreBuildEvent>
+      <Command>
+      </Command>
+    </PreBuildEvent>
+    <PostBuildEvent>
+      <Command>echo "LocalizeBugFix Compiling"
+
+
+
+
+copy /Y "$(TargetDir)localizebugfix.dll" "D:\HLDS\cstrike\addons\localizebugfix\localizebugfix.dll"
+
+
+
+
+
+copy /Y "$(TargetDir)localizebugfix.dll" "C:\CrashDumps\localizebugfix.dll"
+
+
+copy /Y "$(TargetDir)localizebugfix.pdb" "C:\CrashDumps\localizebugfix.pdb"
+
+
+
+
+
+rmdir /q /s Release
+
+
+IF EXIST "$(ProjectDir)ServerStart.bat" (CALL "$(ProjectDir)ServerStart.bat" "$(ProjectDir)..\" "$(ProjectDir)..\")</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/msvc10/localizebugfix.vcxproj.filters b/msvc10/localizebugfix.vcxproj.filters
new file mode 100644
index 0000000..62a4779
--- /dev/null
+++ b/msvc10/localizebugfix.vcxproj.filters
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Файлы исходного кода">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Заголовочные файлы">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Файлы ресурсов">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\meta_api.cpp">
+      <Filter>Файлы исходного кода</Filter>
+    </ClCompile>
+    <ClCompile Include="..\main.cpp">
+      <Filter>Файлы исходного кода</Filter>
+    </ClCompile>
+    <ClCompile Include="..\memory.cpp">
+      <Filter>Файлы исходного кода</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\include\main.h">
+      <Filter>Заголовочные файлы</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\CVector.h">
+      <Filter>Заголовочные файлы</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\memory.h">
+      <Filter>Заголовочные файлы</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/sdk/hlsdk/common/beamdef.h b/sdk/hlsdk/common/beamdef.h
new file mode 100644
index 0000000..e0d1096
--- /dev/null
+++ b/sdk/hlsdk/common/beamdef.h
@@ -0,0 +1,64 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined ( BEAMDEFH )
+#define BEAMDEFH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#define FBEAM_STARTENTITY		0x00000001
+#define FBEAM_ENDENTITY			0x00000002
+#define FBEAM_FADEIN			0x00000004
+#define FBEAM_FADEOUT			0x00000008
+#define FBEAM_SINENOISE			0x00000010
+#define FBEAM_SOLID				0x00000020
+#define FBEAM_SHADEIN			0x00000040
+#define FBEAM_SHADEOUT			0x00000080
+#define FBEAM_STARTVISIBLE		0x10000000		// Has this client actually seen this beam's start entity yet?
+#define FBEAM_ENDVISIBLE		0x20000000		// Has this client actually seen this beam's end entity yet?
+#define FBEAM_ISACTIVE			0x40000000
+#define FBEAM_FOREVER			0x80000000
+
+typedef struct beam_s BEAM;
+struct beam_s
+{
+	BEAM		*next;
+	int			type;
+	int			flags;
+	vec3_t		source;
+	vec3_t		target;
+	vec3_t		delta;
+	float		t;		// 0 .. 1 over lifetime of beam
+	float		freq;
+	float		die;
+	float		width;
+	float		amplitude;
+	float		r, g, b;
+	float		brightness;
+	float		speed;
+	float		frameRate;
+	float		frame;
+	int			segments;
+	int			startEntity;
+	int			endEntity;
+	int			modelIndex;
+	int			frameCount;
+	struct model_s		*pFollowModel;
+	struct particle_s	*particles;
+};
+
+#endif
diff --git a/sdk/hlsdk/common/cl_entity.h b/sdk/hlsdk/common/cl_entity.h
new file mode 100644
index 0000000..0371a68
--- /dev/null
+++ b/sdk/hlsdk/common/cl_entity.h
@@ -0,0 +1,117 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+// cl_entity.h
+#if !defined( CL_ENTITYH )
+#define CL_ENTITYH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef struct efrag_s
+{
+	struct mleaf_s		*leaf;
+	struct efrag_s		*leafnext;
+	struct cl_entity_s	*entity;
+	struct efrag_s		*entnext;
+} efrag_t;
+
+typedef struct
+{
+	byte					mouthopen;		// 0 = mouth closed, 255 = mouth agape
+	byte					sndcount;		// counter for running average
+	int						sndavg;			// running average
+} mouth_t;
+
+typedef struct
+{
+	float					prevanimtime;  
+	float					sequencetime;
+	byte					prevseqblending[2];
+	vec3_t					prevorigin;
+	vec3_t					prevangles;
+
+	int						prevsequence;
+	float					prevframe;
+
+	byte					prevcontroller[4];
+	byte					prevblending[2];
+} latchedvars_t;
+
+typedef struct
+{
+	// Time stamp for this movement
+	float					animtime;
+
+	vec3_t					origin;
+	vec3_t					angles;
+} position_history_t;
+
+typedef struct cl_entity_s cl_entity_t;
+
+#define HISTORY_MAX		64  // Must be power of 2
+#define HISTORY_MASK	( HISTORY_MAX - 1 )
+
+
+#if !defined( ENTITY_STATEH )
+#include "entity_state.h"
+#endif
+
+#if !defined( PROGS_H )
+#include "progs.h"
+#endif
+
+struct cl_entity_s
+{
+	int						index;      // Index into cl_entities ( should match actual slot, but not necessarily )
+
+	qboolean				player;     // True if this entity is a "player"
+	
+	entity_state_t			baseline;   // The original state from which to delta during an uncompressed message
+	entity_state_t			prevstate;  // The state information from the penultimate message received from the server
+	entity_state_t			curstate;   // The state information from the last message received from server
+
+	int						current_position;  // Last received history update index
+	position_history_t		ph[ HISTORY_MAX ];   // History of position and angle updates for this player
+
+	mouth_t					mouth;			// For synchronizing mouth movements.
+
+	latchedvars_t			latched;		// Variables used by studio model rendering routines
+
+	// Information based on interplocation, extrapolation, prediction, or just copied from last msg received.
+	//
+	float					lastmove;
+
+	// Actual render position and angles
+	vec3_t					origin;
+	vec3_t					angles;
+
+	// Attachment points
+	vec3_t					attachment[4];
+
+	// Other entity local information
+	int						trivial_accept;
+
+	struct model_s			*model;			// cl.model_precache[ curstate.modelindes ];  all visible entities have a model
+	struct efrag_s			*efrag;			// linked list of efrags
+	struct mnode_s			*topnode;		// for bmodels, first world node that splits bmodel, or NULL if not split
+
+	float					syncbase;		// for client-side animations -- used by obsolete alias animation system, remove?
+	int						visframe;		// last frame this entity was found in an active leaf
+	colorVec				cvFloorColor;
+};
+
+#endif // !CL_ENTITYH
diff --git a/sdk/hlsdk/common/com_model.h b/sdk/hlsdk/common/com_model.h
new file mode 100644
index 0000000..c87c980
--- /dev/null
+++ b/sdk/hlsdk/common/com_model.h
@@ -0,0 +1,353 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+// com_model.h
+#if !defined( COM_MODEL_H )
+#define COM_MODEL_H
+#if defined( _WIN32 )
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#define STUDIO_RENDER 1
+#define STUDIO_EVENTS 2
+
+#define MAX_CLIENTS			32
+#define	MAX_EDICTS			900
+
+#define MAX_MODEL_NAME		64
+#define MAX_MAP_HULLS		4
+#define	MIPLEVELS			4
+#define	NUM_AMBIENTS		4		// automatic ambient sounds
+#define	MAXLIGHTMAPS		4
+#define	PLANE_ANYZ			5
+
+#define ALIAS_Z_CLIP_PLANE	5
+
+// flags in finalvert_t.flags
+#define ALIAS_LEFT_CLIP				0x0001
+#define ALIAS_TOP_CLIP				0x0002
+#define ALIAS_RIGHT_CLIP			0x0004
+#define ALIAS_BOTTOM_CLIP			0x0008
+#define ALIAS_Z_CLIP				0x0010
+#define ALIAS_ONSEAM				0x0020
+#define ALIAS_XY_CLIP_MASK			0x000F
+
+#define	ZISCALE	((float)0x8000)
+
+#define CACHE_SIZE	32		// used to align key data structures
+
+typedef enum
+{
+	mod_brush, 
+	mod_sprite, 
+	mod_alias, 
+	mod_studio
+} modtype_t;
+
+// must match definition in modelgen.h
+#ifndef SYNCTYPE_T
+#define SYNCTYPE_T
+
+typedef enum
+{
+	ST_SYNC=0,
+	ST_RAND
+} synctype_t;
+
+#endif
+
+typedef struct
+{
+	float		mins[3], maxs[3];
+	float		origin[3];
+	int			headnode[MAX_MAP_HULLS];
+	int			visleafs;		// not including the solid leaf 0
+	int			firstface, numfaces;
+} dmodel_t;
+
+// plane_t structure
+typedef struct mplane_s
+{
+	vec3_t	normal;			// surface normal
+	float	dist;			// closest appoach to origin
+	byte	type;			// for texture axis selection and fast side tests
+	byte	signbits;		// signx + signy<<1 + signz<<1
+	byte	pad[2];
+} mplane_t;
+
+typedef struct
+{
+	vec3_t		position;
+} mvertex_t;
+
+typedef struct
+{
+	unsigned short	v[2];
+	unsigned int	cachededgeoffset;
+} medge_t;
+
+typedef struct texture_s
+{
+	char		name[16];
+	unsigned	width, height;
+	int			anim_total;				// total tenths in sequence ( 0 = no)
+	int			anim_min, anim_max;		// time for this frame min <=time< max
+	struct texture_s *anim_next;		// in the animation sequence
+	struct texture_s *alternate_anims;	// bmodels in frame 1 use these
+	unsigned	offsets[MIPLEVELS];		// four mip maps stored
+	unsigned	paloffset;
+} texture_t;
+
+typedef struct
+{
+	float		vecs[2][4];		// [s/t] unit vectors in world space. 
+								// [i][3] is the s/t offset relative to the origin.
+								// s or t = dot(3Dpoint,vecs[i])+vecs[i][3]
+	float		mipadjust;		// ?? mipmap limits for very small surfaces
+	texture_t	*texture;
+	int			flags;			// sky or slime, no lightmap or 256 subdivision
+} mtexinfo_t;
+
+typedef struct mnode_s
+{
+// common with leaf
+	int			contents;		// 0, to differentiate from leafs
+	int			visframe;		// node needs to be traversed if current
+	
+	short		minmaxs[6];		// for bounding box culling
+
+	struct mnode_s	*parent;
+
+// node specific
+	mplane_t	*plane;
+	struct mnode_s	*children[2];	
+
+	unsigned short		firstsurface;
+	unsigned short		numsurfaces;
+} mnode_t;
+
+typedef struct msurface_s	msurface_t;
+typedef struct decal_s		decal_t;
+
+// JAY: Compress this as much as possible
+struct decal_s
+{
+	decal_t		*pnext;			// linked list for each surface
+	msurface_t	*psurface;		// Surface id for persistence / unlinking
+	short		dx;				// Offsets into surface texture (in texture coordinates, so we don't need floats)
+	short		dy;
+	short		texture;		// Decal texture
+	byte		scale;			// Pixel scale
+	byte		flags;			// Decal flags
+
+	short		entityIndex;	// Entity this is attached to
+};
+
+typedef struct mleaf_s
+{
+// common with node
+	int			contents;		// wil be a negative contents number
+	int			visframe;		// node needs to be traversed if current
+
+	short		minmaxs[6];		// for bounding box culling
+
+	struct mnode_s	*parent;
+
+// leaf specific
+	byte		*compressed_vis;
+	struct efrag_s	*efrags;
+
+	msurface_t	**firstmarksurface;
+	int			nummarksurfaces;
+	int			key;			// BSP sequence number for leaf's contents
+	byte		ambient_sound_level[NUM_AMBIENTS];
+} mleaf_t;
+
+struct msurface_s
+{
+	int			visframe;		// should be drawn when node is crossed
+
+	int			dlightframe;	// last frame the surface was checked by an animated light
+	int			dlightbits;		// dynamically generated. Indicates if the surface illumination 
+								// is modified by an animated light.
+
+	mplane_t	*plane;			// pointer to shared plane			
+	int			flags;			// see SURF_ #defines
+
+	int			firstedge;	// look up in model->surfedges[], negative numbers
+	int			numedges;	// are backwards edges
+	
+// surface generation data
+	struct surfcache_s	*cachespots[MIPLEVELS];
+
+	short		texturemins[2]; // smallest s/t position on the surface.
+	short		extents[2];		// ?? s/t texture size, 1..256 for all non-sky surfaces
+
+	mtexinfo_t	*texinfo;		
+	
+// lighting info
+	byte		styles[MAXLIGHTMAPS]; // index into d_lightstylevalue[] for animated lights 
+									  // no one surface can be effected by more than 4 
+									  // animated lights.
+	color24		*samples;
+	
+	decal_t		*pdecals;
+};
+
+typedef struct
+{
+	int			planenum;
+	short		children[2];	// negative numbers are contents
+} dclipnode_t;
+
+typedef struct hull_s
+{
+	dclipnode_t	*clipnodes;
+	mplane_t	*planes;
+	int			firstclipnode;
+	int			lastclipnode;
+	vec3_t		clip_mins;
+	vec3_t		clip_maxs;
+} hull_t;
+
+#if !defined( CACHE_USER ) && !defined( QUAKEDEF_H )
+#define CACHE_USER
+typedef struct cache_user_s
+{
+	void	*data;
+} cache_user_t;
+#endif
+
+typedef struct model_s
+{
+	char		name[ MAX_MODEL_NAME ];
+	qboolean	needload;		// bmodels and sprites don't cache normally
+
+	modtype_t	type;
+	int			numframes;
+	synctype_t	synctype;
+	
+	int			flags;
+
+//
+// volume occupied by the model
+//		
+	vec3_t		mins, maxs;
+	float		radius;
+
+//
+// brush model
+//
+	int			firstmodelsurface, nummodelsurfaces;
+
+	int			numsubmodels;
+	dmodel_t	*submodels;
+
+	int			numplanes;
+	mplane_t	*planes;
+
+	int			numleafs;		// number of visible leafs, not counting 0
+	struct mleaf_s		*leafs;
+
+	int			numvertexes;
+	mvertex_t	*vertexes;
+
+	int			numedges;
+	medge_t		*edges;
+
+	int			numnodes;
+	mnode_t		*nodes;
+
+	int			numtexinfo;
+	mtexinfo_t	*texinfo;
+
+	int			numsurfaces;
+	msurface_t	*surfaces;
+
+	int			numsurfedges;
+	int			*surfedges;
+
+	int			numclipnodes;
+	dclipnode_t	*clipnodes;
+
+	int			nummarksurfaces;
+	msurface_t	**marksurfaces;
+
+	hull_t		hulls[MAX_MAP_HULLS];
+
+	int			numtextures;
+	texture_t	**textures;
+
+	byte		*visdata;
+
+	color24		*lightdata;
+
+	char		*entities;
+
+//
+// additional model data
+//
+	cache_user_t	cache;		// only access through Mod_Extradata
+
+} model_t;
+
+typedef vec_t vec4_t[4];
+
+typedef struct alight_s
+{
+	int			ambientlight;	// clip at 128
+	int			shadelight;		// clip at 192 - ambientlight
+	vec3_t		color;
+	float		*plightvec;
+} alight_t;
+
+typedef struct auxvert_s
+{
+	float	fv[3];		// viewspace x, y
+} auxvert_t;
+
+#include "custom.h"
+
+#define	MAX_INFO_STRING			256
+#define	MAX_SCOREBOARDNAME		32
+typedef struct player_info_s
+{
+	// User id on server
+	int		userid;
+
+	// User info string
+	char	userinfo[ MAX_INFO_STRING ];
+
+	// Name
+	char	name[ MAX_SCOREBOARDNAME ];
+
+	// Spectator or not, unused
+	int		spectator;
+
+	int		ping;
+	int		packet_loss;
+
+	// skin information
+	char	model[MAX_QPATH];
+	int		topcolor;
+	int		bottomcolor;
+
+	// last frame rendered
+	int		renderframe;	
+
+	// Gait frame estimation
+	int		gaitsequence;
+	float	gaitframe;
+	float	gaityaw;
+	vec3_t	prevgaitorigin;
+
+	customization_t customdata;
+} player_info_t;
+
+#endif // #define COM_MODEL_H
diff --git a/sdk/hlsdk/common/con_nprint.h b/sdk/hlsdk/common/con_nprint.h
new file mode 100644
index 0000000..c563138
--- /dev/null
+++ b/sdk/hlsdk/common/con_nprint.h
@@ -0,0 +1,33 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( CON_NPRINTH )
+#define CON_NPRINTH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef struct con_nprint_s
+{
+	int		index;			// Row #
+	float	time_to_live;	// # of seconds before it dissappears
+	float	color[ 3 ];		// RGB colors ( 0.0 -> 1.0 scale )
+} con_nprint_t;
+
+void Con_NPrintf( int idx, char *fmt, ... );
+void Con_NXPrintf( struct con_nprint_s *info, char *fmt, ... );
+
+#endif
diff --git a/sdk/hlsdk/common/const.h b/sdk/hlsdk/common/const.h
new file mode 100644
index 0000000..c9b26a8
--- /dev/null
+++ b/sdk/hlsdk/common/const.h
@@ -0,0 +1,776 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef CONST_H
+#define CONST_H
+//
+// Constants shared by the engine and dlls
+// This header file included by engine files and DLL files.
+// Most came from server.h
+
+// edict->flags
+#define	FL_FLY					(1<<0)	// Changes the SV_Movestep() behavior to not need to be on ground
+#define	FL_SWIM					(1<<1)	// Changes the SV_Movestep() behavior to not need to be on ground (but stay in water)
+#define	FL_CONVEYOR				(1<<2)
+#define	FL_CLIENT				(1<<3)
+#define	FL_INWATER				(1<<4)
+#define	FL_MONSTER				(1<<5)
+#define	FL_GODMODE				(1<<6)
+#define	FL_NOTARGET				(1<<7)
+#define	FL_SKIPLOCALHOST		(1<<8)	// Don't send entity to local host, it's predicting this entity itself
+#define	FL_ONGROUND				(1<<9)	// At rest / on the ground
+#define	FL_PARTIALGROUND		(1<<10)	// not all corners are valid
+#define	FL_WATERJUMP			(1<<11)	// player jumping out of water
+#define FL_FROZEN				(1<<12) // Player is frozen for 3rd person camera
+#define FL_FAKECLIENT			(1<<13)	// JAC: fake client, simulated server side; don't send network messages to them
+#define FL_DUCKING				(1<<14)	// Player flag -- Player is fully crouched
+#define FL_FLOAT				(1<<15)	// Apply floating force to this entity when in water
+#define FL_GRAPHED				(1<<16) // worldgraph has this ent listed as something that blocks a connection
+
+// UNDONE: Do we need these?
+#define FL_IMMUNE_WATER			(1<<17)
+#define	FL_IMMUNE_SLIME			(1<<18)
+#define FL_IMMUNE_LAVA			(1<<19)
+
+#define FL_PROXY				(1<<20)	// This is a spectator proxy
+#define FL_ALWAYSTHINK			(1<<21)	// Brush model flag -- call think every frame regardless of nextthink - ltime (for constantly changing velocity/path)
+#define FL_BASEVELOCITY			(1<<22)	// Base velocity has been applied this frame (used to convert base velocity into momentum)
+#define FL_MONSTERCLIP			(1<<23)	// Only collide in with monsters who have FL_MONSTERCLIP set
+#define FL_ONTRAIN				(1<<24) // Player is _controlling_ a train, so movement commands should be ignored on client during prediction.
+#define FL_WORLDBRUSH			(1<<25)	// Not moveable/removeable brush entity (really part of the world, but represented as an entity for transparency or something)
+#define FL_SPECTATOR            (1<<26) // This client is a spectator, don't run touch functions, etc.
+#define FL_CUSTOMENTITY			(1<<29)	// This is a custom entity
+#define FL_KILLME				(1<<30)	// This entity is marked for death -- This allows the engine to kill ents at the appropriate time
+#define FL_DORMANT				(1<<31)	// Entity is dormant, no updates to client
+
+
+// Goes into globalvars_t.trace_flags
+#define FTRACE_SIMPLEBOX		(1<<0)	// Traceline with a simple box
+
+
+// walkmove modes
+#define	WALKMOVE_NORMAL		0 // normal walkmove
+#define WALKMOVE_WORLDONLY	1 // doesn't hit ANY entities, no matter what the solid type
+#define WALKMOVE_CHECKONLY	2 // move, but don't touch triggers
+
+// edict->movetype values
+#define	MOVETYPE_NONE			0		// never moves
+//#define	MOVETYPE_ANGLENOCLIP	1
+//#define	MOVETYPE_ANGLECLIP		2
+#define	MOVETYPE_WALK			3		// Player only - moving on the ground
+#define	MOVETYPE_STEP			4		// gravity, special edge handling -- monsters use this
+#define	MOVETYPE_FLY			5		// No gravity, but still collides with stuff
+#define	MOVETYPE_TOSS			6		// gravity/collisions
+#define	MOVETYPE_PUSH			7		// no clip to world, push and crush
+#define	MOVETYPE_NOCLIP			8		// No gravity, no collisions, still do velocity/avelocity
+#define	MOVETYPE_FLYMISSILE		9		// extra size to monsters
+#define	MOVETYPE_BOUNCE			10		// Just like Toss, but reflect velocity when contacting surfaces
+#define MOVETYPE_BOUNCEMISSILE	11		// bounce w/o gravity
+#define MOVETYPE_FOLLOW			12		// track movement of aiment
+#define	MOVETYPE_PUSHSTEP		13		// BSP model that needs physics/world collisions (uses nearest hull for world collision)
+
+// edict->solid values
+// NOTE: Some movetypes will cause collisions independent of SOLID_NOT/SOLID_TRIGGER when the entity moves
+// SOLID only effects OTHER entities colliding with this one when they move - UGH!
+#define	SOLID_NOT				0		// no interaction with other objects
+#define	SOLID_TRIGGER			1		// touch on edge, but not blocking
+#define	SOLID_BBOX				2		// touch on edge, block
+#define	SOLID_SLIDEBOX			3		// touch on edge, but not an onground
+#define	SOLID_BSP				4		// bsp clip, touch on edge, block
+
+// edict->deadflag values
+#define	DEAD_NO					0 // alive
+#define	DEAD_DYING				1 // playing death animation or still falling off of a ledge waiting to hit ground
+#define	DEAD_DEAD				2 // dead. lying still.
+#define DEAD_RESPAWNABLE		3
+#define DEAD_DISCARDBODY		4
+
+#define	DAMAGE_NO				0
+#define	DAMAGE_YES				1
+#define	DAMAGE_AIM				2
+
+// entity effects
+#define	EF_BRIGHTFIELD			1	// swirling cloud of particles
+#define	EF_MUZZLEFLASH 			2	// single frame ELIGHT on entity attachment 0
+#define	EF_BRIGHTLIGHT 			4	// DLIGHT centered at entity origin
+#define	EF_DIMLIGHT 			8	// player flashlight
+#define EF_INVLIGHT				16	// get lighting from ceiling
+#define EF_NOINTERP				32	// don't interpolate the next frame
+#define EF_LIGHT				64	// rocket flare glow sprite
+#define EF_NODRAW				128	// don't draw entity
+
+// entity flags
+#define EFLAG_SLERP				1	// do studio interpolation of this entity
+		
+//
+// temp entity events
+//
+#define	TE_BEAMPOINTS		0		// beam effect between two points
+// coord coord coord (start position) 
+// coord coord coord (end position) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define	TE_BEAMENTPOINT		1		// beam effect between point and entity
+// short (start entity) 
+// coord coord coord (end position) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define	TE_GUNSHOT			2		// particle effect plus ricochet sound
+// coord coord coord (position) 
+
+#define	TE_EXPLOSION		3		// additive sprite, 2 dynamic lights, flickering particles, explosion sound, move vertically 8 pps
+// coord coord coord (position) 
+// short (sprite index)
+// byte (scale in 0.1's)
+// byte (framerate)
+// byte (flags)
+//
+// The Explosion effect has some flags to control performance/aesthetic features:
+#define TE_EXPLFLAG_NONE		0	// all flags clear makes default Half-Life explosion
+#define TE_EXPLFLAG_NOADDITIVE	1	// sprite will be drawn opaque (ensure that the sprite you send is a non-additive sprite)
+#define TE_EXPLFLAG_NODLIGHTS	2	// do not render dynamic lights
+#define TE_EXPLFLAG_NOSOUND		4	// do not play client explosion sound
+#define TE_EXPLFLAG_NOPARTICLES	8	// do not draw particles
+
+
+#define	TE_TAREXPLOSION		4		// Quake1 "tarbaby" explosion with sound
+// coord coord coord (position) 
+
+#define	TE_SMOKE			5		// alphablend sprite, move vertically 30 pps
+// coord coord coord (position) 
+// short (sprite index)
+// byte (scale in 0.1's)
+// byte (framerate)
+
+#define	TE_TRACER			6		// tracer effect from point to point
+// coord, coord, coord (start) 
+// coord, coord, coord (end)
+
+#define	TE_LIGHTNING		7		// TE_BEAMPOINTS with simplified parameters
+// coord, coord, coord (start) 
+// coord, coord, coord (end) 
+// byte (life in 0.1's) 
+// byte (width in 0.1's) 
+// byte (amplitude in 0.01's)
+// short (sprite model index)
+
+#define	TE_BEAMENTS			8		
+// short (start entity) 
+// short (end entity) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define	TE_SPARKS			9		// 8 random tracers with gravity, ricochet sprite
+// coord coord coord (position) 
+
+#define	TE_LAVASPLASH		10		// Quake1 lava splash
+// coord coord coord (position) 
+
+#define	TE_TELEPORT			11		// Quake1 teleport splash
+// coord coord coord (position) 
+
+#define TE_EXPLOSION2		12		// Quake1 colormaped (base palette) particle explosion with sound
+// coord coord coord (position) 
+// byte (starting color)
+// byte (num colors)
+
+#define TE_BSPDECAL			13		// Decal from the .BSP file 
+// coord, coord, coord (x,y,z), decal position (center of texture in world)
+// short (texture index of precached decal texture name)
+// short (entity index)
+// [optional - only included if previous short is non-zero (not the world)] short (index of model of above entity)
+
+#define TE_IMPLOSION		14		// tracers moving toward a point
+// coord, coord, coord (position)
+// byte (radius)
+// byte (count)
+// byte (life in 0.1's) 
+
+#define TE_SPRITETRAIL		15		// line of moving glow sprites with gravity, fadeout, and collisions
+// coord, coord, coord (start) 
+// coord, coord, coord (end) 
+// short (sprite index)
+// byte (count)
+// byte (life in 0.1's) 
+// byte (scale in 0.1's) 
+// byte (velocity along vector in 10's)
+// byte (randomness of velocity in 10's)
+
+#define TE_BEAM				16		// obsolete
+
+#define TE_SPRITE			17		// additive sprite, plays 1 cycle
+// coord, coord, coord (position) 
+// short (sprite index) 
+// byte (scale in 0.1's) 
+// byte (brightness)
+
+#define TE_BEAMSPRITE		18		// A beam with a sprite at the end
+// coord, coord, coord (start position) 
+// coord, coord, coord (end position) 
+// short (beam sprite index) 
+// short (end sprite index) 
+
+#define TE_BEAMTORUS		19		// screen aligned beam ring, expands to max radius over lifetime
+// coord coord coord (center position) 
+// coord coord coord (axis and radius) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define TE_BEAMDISK			20		// disk that expands to max radius over lifetime
+// coord coord coord (center position) 
+// coord coord coord (axis and radius) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define TE_BEAMCYLINDER		21		// cylinder that expands to max radius over lifetime
+// coord coord coord (center position) 
+// coord coord coord (axis and radius) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define TE_BEAMFOLLOW		22		// create a line of decaying beam segments until entity stops moving
+// short (entity:attachment to follow)
+// short (sprite index)
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte,byte,byte (color)
+// byte (brightness)
+
+#define TE_GLOWSPRITE		23		
+// coord, coord, coord (pos) short (model index) byte (scale / 10)
+
+#define TE_BEAMRING			24		// connect a beam ring to two entities
+// short (start entity) 
+// short (end entity) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define TE_STREAK_SPLASH	25		// oriented shower of tracers
+// coord coord coord (start position) 
+// coord coord coord (direction vector) 
+// byte (color)
+// short (count)
+// short (base speed)
+// short (ramdon velocity)
+
+#define TE_BEAMHOSE			26		// obsolete
+
+#define TE_DLIGHT			27		// dynamic light, effect world, minor entity effect
+// coord, coord, coord (pos) 
+// byte (radius in 10's) 
+// byte byte byte (color)
+// byte (brightness)
+// byte (life in 10's)
+// byte (decay rate in 10's)
+
+#define TE_ELIGHT			28		// point entity light, no world effect
+// short (entity:attachment to follow)
+// coord coord coord (initial position) 
+// coord (radius)
+// byte byte byte (color)
+// byte (life in 0.1's)
+// coord (decay rate)
+
+#define TE_TEXTMESSAGE		29
+// short 1.2.13 x (-1 = center)
+// short 1.2.13 y (-1 = center)
+// byte Effect 0 = fade in/fade out
+			// 1 is flickery credits
+			// 2 is write out (training room)
+
+// 4 bytes r,g,b,a color1	(text color)
+// 4 bytes r,g,b,a color2	(effect color)
+// ushort 8.8 fadein time
+// ushort 8.8  fadeout time
+// ushort 8.8 hold time
+// optional ushort 8.8 fxtime	(time the highlight lags behing the leading text in effect 2)
+// string text message		(512 chars max sz string)
+#define TE_LINE				30
+// coord, coord, coord		startpos
+// coord, coord, coord		endpos
+// short life in 0.1 s
+// 3 bytes r, g, b
+
+#define TE_BOX				31
+// coord, coord, coord		boxmins
+// coord, coord, coord		boxmaxs
+// short life in 0.1 s
+// 3 bytes r, g, b
+
+#define TE_KILLBEAM			99		// kill all beams attached to entity
+// short (entity)
+
+#define TE_LARGEFUNNEL		100
+// coord coord coord (funnel position)
+// short (sprite index) 
+// short (flags) 
+
+#define	TE_BLOODSTREAM		101		// particle spray
+// coord coord coord (start position)
+// coord coord coord (spray vector)
+// byte (color)
+// byte (speed)
+
+#define	TE_SHOWLINE			102		// line of particles every 5 units, dies in 30 seconds
+// coord coord coord (start position)
+// coord coord coord (end position)
+
+#define TE_BLOOD			103		// particle spray
+// coord coord coord (start position)
+// coord coord coord (spray vector)
+// byte (color)
+// byte (speed)
+
+#define TE_DECAL			104		// Decal applied to a brush entity (not the world)
+// coord, coord, coord (x,y,z), decal position (center of texture in world)
+// byte (texture index of precached decal texture name)
+// short (entity index)
+
+#define TE_FIZZ				105		// create alpha sprites inside of entity, float upwards
+// short (entity)
+// short (sprite index)
+// byte (density)
+
+#define TE_MODEL			106		// create a moving model that bounces and makes a sound when it hits
+// coord, coord, coord (position) 
+// coord, coord, coord (velocity)
+// angle (initial yaw)
+// short (model index)
+// byte (bounce sound type)
+// byte (life in 0.1's)
+
+#define TE_EXPLODEMODEL		107		// spherical shower of models, picks from set
+// coord, coord, coord (origin)
+// coord (velocity)
+// short (model index)
+// short (count)
+// byte (life in 0.1's)
+
+#define TE_BREAKMODEL		108		// box of models or sprites
+// coord, coord, coord (position)
+// coord, coord, coord (size)
+// coord, coord, coord (velocity)
+// byte (random velocity in 10's)
+// short (sprite or model index)
+// byte (count)
+// byte (life in 0.1 secs)
+// byte (flags)
+
+#define TE_GUNSHOTDECAL		109		// decal and ricochet sound
+// coord, coord, coord (position)
+// short (entity index???)
+// byte (decal???)
+
+#define TE_SPRITE_SPRAY		110		// spay of alpha sprites
+// coord, coord, coord (position)
+// coord, coord, coord (velocity)
+// short (sprite index)
+// byte (count)
+// byte (speed)
+// byte (noise)
+
+#define TE_ARMOR_RICOCHET	111		// quick spark sprite, client ricochet sound. 
+// coord, coord, coord (position)
+// byte (scale in 0.1's)
+
+#define TE_PLAYERDECAL		112		// ???
+// byte (playerindex)
+// coord, coord, coord (position)
+// short (entity???)
+// byte (decal number???)
+// [optional] short (model index???)
+
+#define TE_BUBBLES			113		// create alpha sprites inside of box, float upwards
+// coord, coord, coord (min start position)
+// coord, coord, coord (max start position)
+// coord (float height)
+// short (model index)
+// byte (count)
+// coord (speed)
+
+#define TE_BUBBLETRAIL		114		// create alpha sprites along a line, float upwards
+// coord, coord, coord (min start position)
+// coord, coord, coord (max start position)
+// coord (float height)
+// short (model index)
+// byte (count)
+// coord (speed)
+
+#define TE_BLOODSPRITE		115		// spray of opaque sprite1's that fall, single sprite2 for 1..2 secs (this is a high-priority tent)
+// coord, coord, coord (position)
+// short (sprite1 index)
+// short (sprite2 index)
+// byte (color)
+// byte (scale)
+
+#define TE_WORLDDECAL		116		// Decal applied to the world brush
+// coord, coord, coord (x,y,z), decal position (center of texture in world)
+// byte (texture index of precached decal texture name)
+
+#define TE_WORLDDECALHIGH	117		// Decal (with texture index > 256) applied to world brush
+// coord, coord, coord (x,y,z), decal position (center of texture in world)
+// byte (texture index of precached decal texture name - 256)
+
+#define TE_DECALHIGH		118		// Same as TE_DECAL, but the texture index was greater than 256
+// coord, coord, coord (x,y,z), decal position (center of texture in world)
+// byte (texture index of precached decal texture name - 256)
+// short (entity index)
+
+#define TE_PROJECTILE		119		// Makes a projectile (like a nail) (this is a high-priority tent)
+// coord, coord, coord (position)
+// coord, coord, coord (velocity)
+// short (modelindex)
+// byte (life)
+// byte (owner)  projectile won't collide with owner (if owner == 0, projectile will hit any client).
+
+#define TE_SPRAY			120		// Throws a shower of sprites or models
+// coord, coord, coord (position)
+// coord, coord, coord (direction)
+// short (modelindex)
+// byte (count)
+// byte (speed)
+// byte (noise)
+// byte (rendermode)
+
+#define TE_PLAYERSPRITES	121		// sprites emit from a player's bounding box (ONLY use for players!)
+// byte (playernum)
+// short (sprite modelindex)
+// byte (count)
+// byte (variance) (0 = no variance in size) (10 = 10% variance in size)
+
+#define TE_PARTICLEBURST	122		// very similar to lavasplash.
+// coord (origin)
+// short (radius)
+// byte (particle color)
+// byte (duration * 10) (will be randomized a bit)
+
+#define TE_FIREFIELD			123		// makes a field of fire.
+// coord (origin)
+// short (radius) (fire is made in a square around origin. -radius, -radius to radius, radius)
+// short (modelindex)
+// byte (count)
+// byte (flags)
+// byte (duration (in seconds) * 10) (will be randomized a bit)
+//
+// to keep network traffic low, this message has associated flags that fit into a byte:
+#define TEFIRE_FLAG_ALLFLOAT	1 // all sprites will drift upwards as they animate
+#define TEFIRE_FLAG_SOMEFLOAT	2 // some of the sprites will drift upwards. (50% chance)
+#define TEFIRE_FLAG_LOOP		4 // if set, sprite plays at 15 fps, otherwise plays at whatever rate stretches the animation over the sprite's duration.
+#define TEFIRE_FLAG_ALPHA		8 // if set, sprite is rendered alpha blended at 50% else, opaque
+#define TEFIRE_FLAG_PLANAR		16 // if set, all fire sprites have same initial Z instead of randomly filling a cube. 
+
+#define TE_PLAYERATTACHMENT			124 // attaches a TENT to a player (this is a high-priority tent)
+// byte (entity index of player)
+// coord (vertical offset) ( attachment origin.z = player origin.z + vertical offset )
+// short (model index)
+// short (life * 10 );
+
+#define TE_KILLPLAYERATTACHMENTS	125 // will expire all TENTS attached to a player.
+// byte (entity index of player)
+
+#define TE_MULTIGUNSHOT				126 // much more compact shotgun message
+// This message is used to make a client approximate a 'spray' of gunfire.
+// Any weapon that fires more than one bullet per frame and fires in a bit of a spread is
+// a good candidate for MULTIGUNSHOT use. (shotguns)
+//
+// NOTE: This effect makes the client do traces for each bullet, these client traces ignore
+//		 entities that have studio models.Traces are 4096 long.
+//
+// coord (origin)
+// coord (origin)
+// coord (origin)
+// coord (direction)
+// coord (direction)
+// coord (direction)
+// coord (x noise * 100)
+// coord (y noise * 100)
+// byte (count)
+// byte (bullethole decal texture index)
+
+#define TE_USERTRACER				127 // larger message than the standard tracer, but allows some customization.
+// coord (origin)
+// coord (origin)
+// coord (origin)
+// coord (velocity)
+// coord (velocity)
+// coord (velocity)
+// byte ( life * 10 )
+// byte ( color ) this is an index into an array of color vectors in the engine. (0 - )
+// byte ( length * 10 )
+
+
+
+#define	MSG_BROADCAST		0		// unreliable to all
+#define	MSG_ONE				1		// reliable to one (msg_entity)
+#define	MSG_ALL				2		// reliable to all
+#define	MSG_INIT			3		// write to the init string
+#define MSG_PVS				4		// Ents in PVS of org
+#define MSG_PAS				5		// Ents in PAS of org
+#define MSG_PVS_R			6		// Reliable to PVS
+#define MSG_PAS_R			7		// Reliable to PAS
+#define MSG_ONE_UNRELIABLE	8		// Send to one client, but don't put in reliable stream, put in unreliable datagram ( could be dropped )
+#define	MSG_SPEC			9		// Sends to all spectator proxies
+
+// contents of a spot in the world
+#define	CONTENTS_EMPTY		-1
+#define	CONTENTS_SOLID		-2
+#define	CONTENTS_WATER		-3
+#define	CONTENTS_SLIME		-4
+#define	CONTENTS_LAVA		-5
+#define	CONTENTS_SKY		-6
+/* These additional contents constants are defined in bspfile.h
+#define	CONTENTS_ORIGIN		-7		// removed at csg time
+#define	CONTENTS_CLIP		-8		// changed to contents_solid
+#define	CONTENTS_CURRENT_0		-9
+#define	CONTENTS_CURRENT_90		-10
+#define	CONTENTS_CURRENT_180	-11
+#define	CONTENTS_CURRENT_270	-12
+#define	CONTENTS_CURRENT_UP		-13
+#define	CONTENTS_CURRENT_DOWN	-14
+
+#define CONTENTS_TRANSLUCENT	-15
+*/
+#define	CONTENTS_LADDER		-16
+
+#define	CONTENT_FLYFIELD			-17
+#define	CONTENT_GRAVITY_FLYFIELD	-18
+#define	CONTENT_FOG					-19
+
+#define CONTENT_EMPTY	-1
+#define CONTENT_SOLID	-2
+#define	CONTENT_WATER	-3
+#define CONTENT_SLIME	-4
+#define CONTENT_LAVA	-5
+#define CONTENT_SKY		-6
+
+// channels
+#define CHAN_AUTO			0
+#define CHAN_WEAPON			1
+#define	CHAN_VOICE			2
+#define CHAN_ITEM			3
+#define	CHAN_BODY			4
+#define CHAN_STREAM			5			// allocate stream channel from the static or dynamic area
+#define CHAN_STATIC			6			// allocate channel from the static area 
+#define CHAN_NETWORKVOICE_BASE	7		// voice data coming across the network
+#define CHAN_NETWORKVOICE_END	500		// network voice data reserves slots (CHAN_NETWORKVOICE_BASE through CHAN_NETWORKVOICE_END).
+
+// attenuation values
+#define ATTN_NONE		0
+#define	ATTN_NORM		(float)0.8
+#define ATTN_IDLE		(float)2
+#define ATTN_STATIC		(float)1.25 
+
+// pitch values
+#define	PITCH_NORM		100			// non-pitch shifted
+#define PITCH_LOW		95			// other values are possible - 0-255, where 255 is very high
+#define PITCH_HIGH		120
+
+// volume values
+#define VOL_NORM		1.0
+
+// plats
+#define	PLAT_LOW_TRIGGER	1
+
+// Trains
+#define	SF_TRAIN_WAIT_RETRIGGER	1
+#define SF_TRAIN_START_ON		4		// Train is initially moving
+#define SF_TRAIN_PASSABLE		8		// Train is not solid -- used to make water trains
+
+// buttons
+#ifndef IN_BUTTONS_H
+#include "in_buttons.h"
+#endif
+
+// Break Model Defines
+
+#define BREAK_TYPEMASK	0x4F
+#define BREAK_GLASS		0x01
+#define BREAK_METAL		0x02
+#define BREAK_FLESH		0x04
+#define BREAK_WOOD		0x08
+
+#define BREAK_SMOKE		0x10
+#define BREAK_TRANS		0x20
+#define BREAK_CONCRETE	0x40
+#define BREAK_2			0x80
+
+// Colliding temp entity sounds
+
+#define BOUNCE_GLASS	BREAK_GLASS
+#define	BOUNCE_METAL	BREAK_METAL
+#define BOUNCE_FLESH	BREAK_FLESH
+#define BOUNCE_WOOD		BREAK_WOOD
+#define BOUNCE_SHRAP	0x10
+#define BOUNCE_SHELL	0x20
+#define	BOUNCE_CONCRETE BREAK_CONCRETE
+#define BOUNCE_SHOTSHELL 0x80
+
+// Temp entity bounce sound types
+#define TE_BOUNCE_NULL		0
+#define TE_BOUNCE_SHELL		1
+#define TE_BOUNCE_SHOTSHELL	2
+
+// Rendering constants
+enum 
+{	
+	kRenderNormal,			// src
+	kRenderTransColor,		// c*a+dest*(1-a)
+	kRenderTransTexture,	// src*a+dest*(1-a)
+	kRenderGlow,			// src*a+dest -- No Z buffer checks
+	kRenderTransAlpha,		// src*srca+dest*(1-srca)
+	kRenderTransAdd,		// src*a+dest
+};
+
+enum 
+{	
+	kRenderFxNone = 0, 
+	kRenderFxPulseSlow, 
+	kRenderFxPulseFast, 
+	kRenderFxPulseSlowWide, 
+	kRenderFxPulseFastWide, 
+	kRenderFxFadeSlow, 
+	kRenderFxFadeFast, 
+	kRenderFxSolidSlow, 
+	kRenderFxSolidFast, 	   
+	kRenderFxStrobeSlow, 
+	kRenderFxStrobeFast, 
+	kRenderFxStrobeFaster, 
+	kRenderFxFlickerSlow, 
+	kRenderFxFlickerFast,
+	kRenderFxNoDissipation,
+	kRenderFxDistort,			// Distort/scale/translate flicker
+	kRenderFxHologram,			// kRenderFxDistort + distance fade
+	kRenderFxDeadPlayer,		// kRenderAmt is the player index
+	kRenderFxExplode,			// Scale up really big!
+	kRenderFxGlowShell,			// Glowing Shell
+	kRenderFxClampMinScale,		// Keep this sprite from getting very small (SPRITES only!)
+};
+
+
+typedef int	func_t;
+typedef int	string_t;
+
+typedef unsigned char 		byte;
+typedef unsigned short 		word;
+#define _DEF_BYTE_
+
+#undef true
+#undef false
+
+#ifndef __cplusplus
+typedef enum {false, true}	qboolean;
+#else 
+typedef int qboolean;
+#endif
+
+typedef struct
+{
+	byte r, g, b;
+} color24;
+
+typedef struct
+{
+	unsigned r, g, b, a;
+} colorVec;
+
+#ifdef _WIN32
+#pragma pack(push,2)
+#endif
+
+typedef struct
+{
+	unsigned short r, g, b, a;
+} PackedColorVec;
+
+#ifdef _WIN32
+#pragma pack(pop)
+#endif
+typedef struct link_s
+{
+	struct link_s	*prev, *next;
+} link_t;
+
+typedef struct edict_s edict_t;
+
+typedef struct
+{
+	vec3_t	normal;
+	float	dist;
+} plane_t;
+
+typedef struct
+{
+	qboolean	allsolid;	// if true, plane is not valid
+	qboolean	startsolid;	// if true, the initial point was in a solid area
+	qboolean	inopen, inwater;
+	float	fraction;		// time completed, 1.0 = didn't hit anything
+	vec3_t	endpos;			// final position
+	plane_t	plane;			// surface normal at impact
+	edict_t	*ent;			// entity the surface is on
+	int		hitgroup;		// 0 == generic, non zero is specific body part
+} trace_t;
+
+#endif
+
diff --git a/sdk/hlsdk/common/crc.h b/sdk/hlsdk/common/crc.h
new file mode 100644
index 0000000..55cb234
--- /dev/null
+++ b/sdk/hlsdk/common/crc.h
@@ -0,0 +1,54 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+/* crc.h */
+#ifndef CRC_H
+#define CRC_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+// MD5 Hash
+typedef struct
+{
+	unsigned int buf[4];
+    unsigned int bits[2];
+    unsigned char in[64];
+} MD5Context_t;
+
+
+typedef unsigned long CRC32_t;
+void CRC32_Init(CRC32_t *pulCRC);
+CRC32_t CRC32_Final(CRC32_t pulCRC);
+void CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len);
+void CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch);
+int CRC_File(CRC32_t *crcvalue, char *pszFileName);
+
+unsigned char COM_BlockSequenceCRCByte (unsigned char *base, int length, int sequence);
+
+void MD5Init(MD5Context_t *context);
+void MD5Update(MD5Context_t *context, unsigned char const *buf,
+               unsigned int len);
+void MD5Final(unsigned char digest[16], MD5Context_t *context);
+void Transform(unsigned int buf[4], unsigned int const in[16]);
+
+int MD5_Hash_File(unsigned char digest[16], char *pszFileName, int bUsefopen, int bSeed, unsigned int seed[4]);
+char *MD5_Print(unsigned char hash[16]);
+int MD5_Hash_CachedFile(unsigned char digest[16], unsigned char *pCache, int nFileSize, int bSeed, unsigned int seed[4]);
+
+int CRC_MapFile(CRC32_t *crcvalue, char *pszFileName);
+
+#endif
diff --git a/sdk/hlsdk/common/cvardef.h b/sdk/hlsdk/common/cvardef.h
new file mode 100644
index 0000000..8390134
--- /dev/null
+++ b/sdk/hlsdk/common/cvardef.h
@@ -0,0 +1,36 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef CVARDEF_H
+#define CVARDEF_H
+
+#define	FCVAR_ARCHIVE		(1<<0)	// set to cause it to be saved to vars.rc
+#define	FCVAR_USERINFO		(1<<1)	// changes the client's info string
+#define	FCVAR_SERVER		(1<<2)	// notifies players when changed
+#define FCVAR_EXTDLL		(1<<3)	// defined by external DLL
+#define FCVAR_CLIENTDLL     (1<<4)  // defined by the client dll
+#define FCVAR_PROTECTED     (1<<5)  // It's a server cvar, but we don't send the data since it's a password, etc.  Sends 1 if it's not bland/zero, 0 otherwise as value
+#define FCVAR_SPONLY        (1<<6)  // This cvar cannot be changed by clients connected to a multiplayer server.
+#define FCVAR_PRINTABLEONLY (1<<7)  // This cvar's string cannot contain unprintable characters ( e.g., used for player name etc ).
+#define FCVAR_UNLOGGED		(1<<8)  // If this is a FCVAR_SERVER, don't log changes to the log file / console if we are creating a log
+
+typedef struct cvar_s
+{
+	char	*name;
+	char	*string;
+	int		flags;
+	float	value;
+	struct cvar_s *next;
+} cvar_t;
+#endif
diff --git a/sdk/hlsdk/common/demo_api.h b/sdk/hlsdk/common/demo_api.h
new file mode 100644
index 0000000..0130679
--- /dev/null
+++ b/sdk/hlsdk/common/demo_api.h
@@ -0,0 +1,33 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined ( DEMO_APIH )
+#define DEMO_APIH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef struct demo_api_s
+{
+	int		( *IsRecording )	( void );
+	int		( *IsPlayingback )	( void );
+	int		( *IsTimeDemo )		( void );
+	void	( *WriteBuffer )	( int size, unsigned char *buffer );
+} demo_api_t;
+
+extern demo_api_t demoapi;
+
+#endif
diff --git a/sdk/hlsdk/common/director_cmds.h b/sdk/hlsdk/common/director_cmds.h
new file mode 100644
index 0000000..4c8fdd5
--- /dev/null
+++ b/sdk/hlsdk/common/director_cmds.h
@@ -0,0 +1,38 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+// director_cmds.h
+// sub commands for svc_director
+
+#define DRC_ACTIVE				0	// tells client that he's an spectator and will get director command
+#define DRC_STATUS				1	// send status infos about proxy 
+#define DRC_CAMERA				2	// set the actual director camera position
+#define DRC_EVENT				3	// informs the dircetor about ann important game event
+
+
+#define DRC_FLAG_PRIO_MASK		0x0F	//	priorities between 0 and 15 (15 most important)
+#define DRC_FLAG_SIDE			(1<<4)	
+#define DRC_FLAG_DRAMATIC		(1<<5)
+
+
+
+// commands of the director API function CallDirectorProc(...)
+
+#define DRCAPI_NOP					0	// no operation
+#define DRCAPI_ACTIVE				1	// de/acivates director mode in engine
+#define DRCAPI_STATUS				2   // request proxy information
+#define DRCAPI_SETCAM				3	// set camera n to given position and angle
+#define DRCAPI_GETCAM				4	// request camera n position and angle
+#define DRCAPI_DIRPLAY				5	// set director time and play with normal speed
+#define DRCAPI_DIRFREEZE			6	// freeze directo at this time
+#define DRCAPI_SETVIEWMODE			7	// overview or 4 cameras 
+#define DRCAPI_SETOVERVIEWPARAMS	8	// sets parameter for overview mode
+#define DRCAPI_SETFOCUS				9	// set the camera which has the input focus
+#define DRCAPI_GETTARGETS			10	// queries engine for player list
+#define DRCAPI_SETVIEWPOINTS		11	// gives engine all waypoints
+
+
diff --git a/sdk/hlsdk/common/dlight.h b/sdk/hlsdk/common/dlight.h
new file mode 100644
index 0000000..6a4f5b3
--- /dev/null
+++ b/sdk/hlsdk/common/dlight.h
@@ -0,0 +1,35 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined ( DLIGHTH )
+#define DLIGHTH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef struct dlight_s
+{
+	vec3_t	origin;
+	float	radius;
+	color24	color;
+	float	die;				// stop lighting after this time
+	float	decay;				// drop this each second
+	float	minlight;			// don't add when contributing less
+	int		key;
+	qboolean	dark;			// subtracts light instead of adding
+} dlight_t;
+
+#endif
diff --git a/sdk/hlsdk/common/dll_state.h b/sdk/hlsdk/common/dll_state.h
new file mode 100644
index 0000000..4065162
--- /dev/null
+++ b/sdk/hlsdk/common/dll_state.h
@@ -0,0 +1,23 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+//DLL State Flags
+
+#define DLL_INACTIVE 0		// no dll
+#define DLL_ACTIVE   1		// dll is running
+#define DLL_PAUSED   2		// dll is paused
+#define DLL_CLOSE    3		// closing down dll
+#define DLL_TRANS    4 		// Level Transition
+
+// DLL Pause reasons
+
+#define DLL_NORMAL        0   // User hit Esc or something.
+#define DLL_QUIT          4   // Quit now
+#define DLL_RESTART       6   // Switch to launcher for linux, does a quit but returns 1
+
+// DLL Substate info ( not relevant )
+#define ENG_NORMAL         (1<<0)
diff --git a/sdk/hlsdk/common/engine_launcher_api.h b/sdk/hlsdk/common/engine_launcher_api.h
new file mode 100644
index 0000000..c669856
--- /dev/null
+++ b/sdk/hlsdk/common/engine_launcher_api.h
@@ -0,0 +1,112 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+// engine/launcher interface
+#if !defined( ENGINE_LAUNCHER_APIH )
+#define ENGINE_LAUNCHER_APIH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+//typedef void ( *xcommand_t ) ( void );
+
+#define RENDERTYPE_UNDEFINED	0
+#define RENDERTYPE_SOFTWARE		1
+#define RENDERTYPE_HARDWARE		2
+
+#define ENGINE_LAUNCHER_API_VERSION 1
+
+typedef struct engine_api_s
+{
+	int		version;
+	int		rendertype;
+	int		size;
+
+	// Functions
+	int		( *GetEngineState )				( void );
+	void	( *Cbuf_AddText )				( char *text ); // append cmd at end of buf
+	void	( *Cbuf_InsertText )			( char *text ); // insert cmd at start of buf
+	void	( *Cmd_AddCommand )				( char *cmd_name, void ( *funcname )( void ) );
+	int		( *Cmd_Argc )					( void );
+	char	*( *Cmd_Args )					( void );
+	char	*( *Cmd_Argv )					( int arg );
+	void	( *Con_Printf )					( char *, ... );
+	void	( *Con_SafePrintf )				( char *, ... );
+	void	( *Cvar_Set )					( char *var_name, char *value );
+	void	( *Cvar_SetValue )				( char *var_name, float value );
+	int		( *Cvar_VariableInt )			( char *var_name );
+	char	*( *Cvar_VariableString )		( char *var_name );
+	float	( *Cvar_VariableValue )			( char *var_name );
+	void	( *ForceReloadProfile )			( void );
+	int		( *GetGameInfo )				( struct GameInfo_s *pGI, char *pszChannel );
+	void	( *GameSetBackground )			( int bBack );
+	void	( *GameSetState )				( int iState );
+	void	( *GameSetSubState )			( int iState );
+	int		( *GetPauseState )				( void );
+	int		( *Host_Frame )					( float time, int iState, int *stateInfo );
+	void	( *Host_GetHostInfo )			( float *fps, int *nActive, int *nSpectators, int *nMaxPlayers, char *pszMap );
+	void	( *Host_Shutdown )				( void );
+	int		( *Game_Init )					( char *lpCmdLine, unsigned char *pMem, int iSize, struct exefuncs_s *pef, void *, int );
+	void	( *IN_ActivateMouse )			( void );
+	void	( *IN_ClearStates )				( void );
+	void	( *IN_DeactivateMouse )			( void );
+	void	( *IN_MouseEvent )				( int mstate );
+	void	( *Keyboard_ReturnToGame )		( void );
+	void	( *Key_ClearStates )			( void );
+	void	( *Key_Event )					( int key, int down );
+	int		( *LoadGame )					( const char *pszSlot );
+	void	( *S_BlockSound )				( void );
+	void	( *S_ClearBuffer )				( void );
+	void	( *S_GetDSPointer )				( struct IDirectSound **lpDS, struct IDirectSoundBuffer **lpDSBuf );
+	void 	*( *S_GetWAVPointer )			( void );
+	void	( *S_UnblockSound )				( void );
+	int		( *SaveGame )					( const char *pszSlot, const char *pszComment );
+	void	( *SetAuth )					( void *pobj );
+	void	( *SetMessagePumpDisableMode )	( int bMode );
+	void	( *SetPauseState )				( int bPause );
+	void	( *SetStartupMode )				( int bMode );
+	void	( *SNDDMA_Shutdown )			( void );
+	void	( *Snd_AcquireBuffer )			( void );
+	void	( *Snd_ReleaseBuffer )			( void );
+	void	( *StoreProfile )				( void );
+	double	( *Sys_FloatTime )				( void );
+	void	( *VID_UpdateWindowVars )		( void *prc, int x, int y );
+	void	( *VID_UpdateVID )				( struct viddef_s *pvid );
+
+	// VGUI interfaces
+	void	( *VGui_CallEngineSurfaceProc )	( void* hwnd, unsigned int msg, unsigned int wparam, long lparam );
+
+	// notifications that the launcher is taking/giving focus to the engine
+	void    ( *EngineTakingFocus )			( void );
+	void    ( *LauncherTakingFocus )		( void );
+
+#ifdef _WIN32
+	// Only filled in by rendertype RENDERTYPE_HARDWARE
+	void	( *GL_Init )					( void );
+	int		( *GL_SetMode )					( HWND hwndGame, HDC *pmaindc, HGLRC *pbaseRC, int fD3D, const char *p, const char *pszCmdLine );
+	void	( *GL_Shutdown )				( HWND hwnd, HDC hdc, HGLRC hglrc );
+
+	void	( *QGL_D3DShared )				( struct tagD3DGlobals *d3dGShared );
+
+	int		( WINAPI *glSwapBuffers )		( HDC dc );
+	void	( *DirectorProc ) ( unsigned int cmd, void * params );
+#else
+	// NOT USED IN LINUX!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	void	( *GL_Init )					( void );
+	void	( *GL_SetMode )					( void );
+	void	( *GL_Shutdown )				( void );
+	void	( *QGL_D3DShared )				( void );
+	void	( *glSwapBuffers )				( void );
+	void	( *DirectorProc )				( void );
+	// LINUX
+#endif
+
+} engine_api_t;
+
+#endif // ENGINE_LAUNCHER_APIH
diff --git a/sdk/hlsdk/common/entity_state.h b/sdk/hlsdk/common/entity_state.h
new file mode 100644
index 0000000..fe4c097
--- /dev/null
+++ b/sdk/hlsdk/common/entity_state.h
@@ -0,0 +1,195 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( ENTITY_STATEH )
+#define ENTITY_STATEH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+// For entityType below
+#define ENTITY_NORMAL		(1<<0)
+#define ENTITY_BEAM			(1<<1)
+
+// Entity state is used for the baseline and for delta compression of a packet of 
+//  entities that is sent to a client.
+typedef struct entity_state_s entity_state_t;
+
+struct entity_state_s
+{
+// Fields which are filled in by routines outside of delta compression
+	int			entityType;
+	// Index into cl_entities array for this entity.
+	int			number;      
+	float		msg_time;
+
+	// Message number last time the player/entity state was updated.
+	int			messagenum;		
+
+	// Fields which can be transitted and reconstructed over the network stream
+	vec3_t		origin;
+	vec3_t		angles;
+
+	int			modelindex;
+	int			sequence;
+	float		frame;
+	int			colormap;
+	short		skin;
+	short		solid;
+	int			effects;
+	float		scale;
+
+	byte		eflags;
+	
+	// Render information
+	int			rendermode;
+	int			renderamt;
+	color24		rendercolor;
+	int			renderfx;
+
+	int			movetype;
+	float		animtime;
+	float		framerate;
+	int			body;
+	byte		controller[4];
+	byte		blending[4];
+	vec3_t		velocity;
+
+	// Send bbox down to client for use during prediction.
+	vec3_t		mins;    
+	vec3_t		maxs;
+
+	int			aiment;
+	// If owned by a player, the index of that player ( for projectiles ).
+	int			owner; 
+
+	// Friction, for prediction.
+	float		friction;       
+	// Gravity multiplier
+	float		gravity;		
+
+// PLAYER SPECIFIC
+	int			team;
+	int			playerclass;
+	int			health;
+	qboolean	spectator;  
+	int         weaponmodel;
+	int			gaitsequence;
+	// If standing on conveyor, e.g.
+	vec3_t		basevelocity;   
+	// Use the crouched hull, or the regular player hull.
+	int			usehull;		
+	// Latched buttons last time state updated.
+	int			oldbuttons;     
+	// -1 = in air, else pmove entity number
+	int			onground;		
+	int			iStepLeft;
+	// How fast we are falling
+	float		flFallVelocity;  
+
+	float		fov;
+	int			weaponanim;
+
+	// Parametric movement overrides
+	vec3_t				startpos;
+	vec3_t				endpos;
+	float				impacttime;
+	float				starttime;
+
+	// For mods
+	int			iuser1;
+	int			iuser2;
+	int			iuser3;
+	int			iuser4;
+	float		fuser1;
+	float		fuser2;
+	float		fuser3;
+	float		fuser4;
+	vec3_t		vuser1;
+	vec3_t		vuser2;
+	vec3_t		vuser3;
+	vec3_t		vuser4;
+};
+
+#include "pm_info.h"
+
+typedef struct clientdata_s
+{
+	vec3_t				origin;
+	vec3_t				velocity;
+
+	int					viewmodel;
+	vec3_t				punchangle;
+	int					flags;
+	int					waterlevel;
+	int					watertype;
+	vec3_t				view_ofs;
+	float				health;
+
+	int					bInDuck;
+
+	int					weapons; // remove?
+	
+	int					flTimeStepSound;
+	int					flDuckTime;
+	int					flSwimTime;
+	int					waterjumptime;
+
+	float				maxspeed;
+
+	float				fov;
+	int					weaponanim;
+
+	int					m_iId;
+	int					ammo_shells;
+	int					ammo_nails;
+	int					ammo_cells;
+	int					ammo_rockets;
+	float				m_flNextAttack;
+	
+	int					tfstate;
+
+	int					pushmsec;
+
+	int					deadflag;
+
+	char				physinfo[ MAX_PHYSINFO_STRING ];
+
+	// For mods
+	int					iuser1;
+	int					iuser2;
+	int					iuser3;
+	int					iuser4;
+	float				fuser1;
+	float				fuser2;
+	float				fuser3;
+	float				fuser4;
+	vec3_t				vuser1;
+	vec3_t				vuser2;
+	vec3_t				vuser3;
+	vec3_t				vuser4;
+} clientdata_t;
+
+#include "weaponinfo.h"
+
+typedef struct local_state_s
+{
+	entity_state_t playerstate;
+	clientdata_t   client;
+	weapon_data_t  weapondata[ 32 ];
+} local_state_t;
+
+#endif // !ENTITY_STATEH
diff --git a/sdk/hlsdk/common/entity_types.h b/sdk/hlsdk/common/entity_types.h
new file mode 100644
index 0000000..ff783df
--- /dev/null
+++ b/sdk/hlsdk/common/entity_types.h
@@ -0,0 +1,26 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+// entity_types.h
+#if !defined( ENTITY_TYPESH )
+#define ENTITY_TYPESH
+
+#define ET_NORMAL		0
+#define ET_PLAYER		1
+#define ET_TEMPENTITY	2
+#define ET_BEAM			3
+// BMODEL or SPRITE that was split across BSP nodes
+#define ET_FRAGMENTED	4
+
+#endif // !ENTITY_TYPESH
diff --git a/sdk/hlsdk/common/event_api.h b/sdk/hlsdk/common/event_api.h
new file mode 100644
index 0000000..c49c25d
--- /dev/null
+++ b/sdk/hlsdk/common/event_api.h
@@ -0,0 +1,53 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined ( EVENT_APIH )
+#define EVENT_APIH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#define EVENT_API_VERSION 1
+
+typedef struct event_api_s
+{
+	int		version;
+	void	( *EV_PlaySound ) ( int ent, float *origin, int channel, const char *sample, float volume, float attenuation, int fFlags, int pitch );
+	void	( *EV_StopSound ) ( int ent, int channel, const char *sample );
+	int		( *EV_FindModelIndex )( const char *pmodel );
+	int		( *EV_IsLocal ) ( int playernum );
+	int		( *EV_LocalPlayerDucking ) ( void );
+	void	( *EV_LocalPlayerViewheight ) ( float * );
+	void	( *EV_LocalPlayerBounds ) ( int hull, float *mins, float *maxs );
+	int		( *EV_IndexFromTrace) ( struct pmtrace_s *pTrace );
+	struct physent_s *( *EV_GetPhysent ) ( int idx );
+	void	( *EV_SetUpPlayerPrediction ) ( int dopred, int bIncludeLocalClient );
+	void	( *EV_PushPMStates ) ( void );
+	void	( *EV_PopPMStates ) ( void );
+	void	( *EV_SetSolidPlayers ) (int playernum);
+	void	( *EV_SetTraceHull ) ( int hull );
+	void	( *EV_PlayerTrace ) ( float *start, float *end, int traceFlags, int ignore_pe, struct pmtrace_s *tr );
+	void	( *EV_WeaponAnimation ) ( int sequence, int body );
+	unsigned short ( *EV_PrecacheEvent ) ( int type, const char* psz );
+	void	( *EV_PlaybackEvent ) ( int flags, const struct edict_s *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 );
+	const char *( *EV_TraceTexture ) ( int ground, float *vstart, float *vend );
+	void	( *EV_StopAllSounds ) ( int entnum, int entchannel );
+	void    ( *EV_KillEvents ) ( int entnum, const char *eventname );
+} event_api_t;
+
+extern event_api_t eventapi;
+
+#endif
diff --git a/sdk/hlsdk/common/event_args.h b/sdk/hlsdk/common/event_args.h
new file mode 100644
index 0000000..7d7d9b3
--- /dev/null
+++ b/sdk/hlsdk/common/event_args.h
@@ -0,0 +1,52 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( EVENT_ARGSH )
+#define EVENT_ARGSH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+// Event was invoked with stated origin
+#define FEVENT_ORIGIN	( 1<<0 )
+
+// Event was invoked with stated angles
+#define FEVENT_ANGLES	( 1<<1 )
+
+typedef struct event_args_s
+{
+	int		flags;
+
+	// Transmitted
+	int		entindex;
+
+	float	origin[3];
+	float	angles[3];
+	float	velocity[3];
+
+	int		ducking;
+
+	float	fparam1;
+	float	fparam2;
+
+	int		iparam1;
+	int		iparam2;
+
+	int		bparam1;
+	int		bparam2;
+} event_args_t;
+
+#endif
diff --git a/sdk/hlsdk/common/event_flags.h b/sdk/hlsdk/common/event_flags.h
new file mode 100644
index 0000000..fb19ae3
--- /dev/null
+++ b/sdk/hlsdk/common/event_flags.h
@@ -0,0 +1,49 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( EVENT_FLAGSH )
+#define EVENT_FLAGSH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+// Skip local host for event send.
+#define FEV_NOTHOST		(1<<0)    
+
+// Send the event reliably.  You must specify the origin and angles and use
+// PLAYBACK_EVENT_FULL for this to work correctly on the server for anything
+// that depends on the event origin/angles.  I.e., the origin/angles are not
+// taken from the invoking edict for reliable events.
+#define FEV_RELIABLE	(1<<1)	 
+
+// Don't restrict to PAS/PVS, send this event to _everybody_ on the server ( useful for stopping CHAN_STATIC
+//  sounds started by client event when client is not in PVS anymore ( hwguy in TFC e.g. ).
+#define FEV_GLOBAL		(1<<2)
+
+// If this client already has one of these events in its queue, just update the event instead of sending it as a duplicate
+//
+#define FEV_UPDATE		(1<<3)
+
+// Only send to entity specified as the invoker
+#define	FEV_HOSTONLY	(1<<4)
+
+// Only send if the event was created on the server.
+#define FEV_SERVER		(1<<5)
+
+// Only issue event client side ( from shared code )
+#define FEV_CLIENT		(1<<6)
+
+#endif
diff --git a/sdk/hlsdk/common/exefuncs.h b/sdk/hlsdk/common/exefuncs.h
new file mode 100644
index 0000000..cf07310
--- /dev/null
+++ b/sdk/hlsdk/common/exefuncs.h
@@ -0,0 +1,50 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+// exefuncs.h
+#ifndef EXEFUNCS_H
+#define EXEFUNCS_H
+
+// Engine hands this to DLLs for functionality callbacks
+typedef struct exefuncs_s
+{
+	int			fMMX;
+	int			iCPUMhz;
+	void		(*unused1)(void);
+	void		(*unused2)(void);
+	void		(*unused3)(void);
+	void		(*unused4)(void);
+	void		(*VID_ForceLockState)(int lk);
+	int			(*VID_ForceUnlockedAndReturnState)(void);
+	void		(*unused5)(void);
+	void		(*unused6)(void);
+	void		(*unused7)(void);
+	void		(*unused8)(void);
+	void		(*unused9)(void);
+	void		(*unused10)(void);
+	void		(*unused11)(void);
+	void		(*unused12)(void);
+	void		(*unused13)(void);
+	void		(*unused14)(void);
+	void		(*unused15)(void);
+	void        (*ErrorMessage)(int nLevel, const char *pszErrorMessage);
+	void		(*unused16)(void);
+	void        (*Sys_Printf)(char *fmt, ...);
+	void		(*unused17)(void);
+	void		(*unused18)(void);
+	void		(*unused19)(void);
+	void		(*unused20)(void);
+	void		(*unused21)(void);
+	void		(*unused22)(void);
+	void		(*unused23)(void);
+	void		(*unused24)(void);
+	void		(*unused25)(void);
+	void		(*unused26)(void);
+	void		(*unused27)(void);
+} exefuncs_t;
+
+#endif
diff --git a/sdk/hlsdk/common/hltv.h b/sdk/hlsdk/common/hltv.h
new file mode 100644
index 0000000..4099b7e
--- /dev/null
+++ b/sdk/hlsdk/common/hltv.h
@@ -0,0 +1,57 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+// hltv.h
+// all shared consts between server, clients and proxy
+
+#ifndef HLTV_H
+#define HLTV_H
+
+#define TYPE_CLIENT				0	// client is a normal HL client (default)
+#define TYPE_PROXY				1	// client is another proxy
+#define TYPE_COMMENTATOR		3	// client is a commentator
+#define TYPE_DEMO				4	// client is a demo file
+// sub commands of svc_hltv:
+#define HLTV_ACTIVE				0	// tells client that he's an spectator and will get director commands
+#define HLTV_STATUS				1	// send status infos about proxy 
+#define HLTV_LISTEN				2	// tell client to listen to a multicast stream
+
+// sub commands of svc_director:
+#define DRC_CMD_NONE				0	// NULL director command
+#define DRC_CMD_START				1	// start director mode
+#define DRC_CMD_EVENT				2	// informs about director command
+#define DRC_CMD_MODE				3	// switches camera modes
+#define DRC_CMD_CAMERA				4	// sets camera registers
+#define DRC_CMD_TIMESCALE			5	// sets time scale
+#define DRC_CMD_MESSAGE				6	// send HUD centerprint
+#define DRC_CMD_SOUND				7	// plays a particular sound
+#define DRC_CMD_STATUS				8	// status info about broadcast
+#define DRC_CMD_BANNER				9	// banner file name for HLTV gui
+#define	DRC_CMD_FADE				10	// send screen fade command
+#define DRC_CMD_SHAKE				11	// send screen shake command
+#define DRC_CMD_STUFFTEXT			12	// like the normal svc_stufftext but as director command
+
+#define DRC_CMD_LAST				12
+
+
+
+// HLTV_EVENT event flags
+#define DRC_FLAG_PRIO_MASK		0x0F	// priorities between 0 and 15 (15 most important)
+#define DRC_FLAG_SIDE			(1<<4)	// 
+#define DRC_FLAG_DRAMATIC		(1<<5)	// is a dramatic scene
+#define DRC_FLAG_SLOWMOTION		(1<<6)  // would look good in SloMo
+#define DRC_FLAG_FACEPLAYER		(1<<7)  // player is doning something (reload/defuse bomb etc)
+#define DRC_FLAG_INTRO			(1<<8)	// is a introduction scene
+#define DRC_FLAG_FINAL			(1<<9)	// is a final scene
+#define DRC_FLAG_NO_RANDOM		(1<<10)	// don't randomize event data
+
+
+#define MAX_DIRECTOR_CMD_PARAMETERS		4
+#define MAX_DIRECTOR_CMD_STRING			128
+
+
+#endif // HLTV_H
diff --git a/sdk/hlsdk/common/in_buttons.h b/sdk/hlsdk/common/in_buttons.h
new file mode 100644
index 0000000..77294ad
--- /dev/null
+++ b/sdk/hlsdk/common/in_buttons.h
@@ -0,0 +1,40 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef IN_BUTTONS_H
+#define IN_BUTTONS_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#define IN_ATTACK	(1 << 0)
+#define IN_JUMP		(1 << 1)
+#define IN_DUCK		(1 << 2)
+#define IN_FORWARD	(1 << 3)
+#define IN_BACK		(1 << 4)
+#define IN_USE		(1 << 5)
+#define IN_CANCEL	(1 << 6)
+#define IN_LEFT		(1 << 7)
+#define IN_RIGHT	(1 << 8)
+#define IN_MOVELEFT	(1 << 9)
+#define IN_MOVERIGHT (1 << 10)
+#define IN_ATTACK2	(1 << 11)
+#define IN_RUN      (1 << 12)
+#define IN_RELOAD	(1 << 13)
+#define IN_ALT1		(1 << 14)
+#define IN_SCORE	(1 << 15)   // Used by client.dll for when scoreboard is held down
+
+#endif // IN_BUTTONS_H
diff --git a/sdk/hlsdk/common/interface.h b/sdk/hlsdk/common/interface.h
new file mode 100644
index 0000000..b49d087
--- /dev/null
+++ b/sdk/hlsdk/common/interface.h
@@ -0,0 +1,129 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+// This header defines the interface convention used in the valve engine.
+// To make an interface and expose it:
+//    1. Derive from IBaseInterface.
+//    2. The interface must be ALL pure virtuals, and have no data members.
+//    3. Define a name for it.
+//    4. In its implementation file, use EXPOSE_INTERFACE or EXPOSE_SINGLE_INTERFACE.
+
+// Versioning
+// There are two versioning cases that are handled by this:
+// 1. You add functions to the end of an interface, so it is binary compatible with the previous interface. In this case, 
+//    you need two EXPOSE_INTERFACEs: one to expose your class as the old interface and one to expose it as the new interface.
+// 2. You update an interface so it's not compatible anymore (but you still want to be able to expose the old interface 
+//    for legacy code). In this case, you need to make a new version name for your new interface, and make a wrapper interface and 
+//    expose it for the old interface.
+
+#ifndef INTERFACE_H
+#define INTERFACE_H
+
+#ifdef __cplusplus
+
+// All interfaces derive from this.
+class IBaseInterface
+{
+public:
+
+	virtual			~IBaseInterface() {}
+};
+
+
+#define CREATEINTERFACE_PROCNAME	"CreateInterface"
+typedef IBaseInterface* (*CreateInterfaceFn)(const char *pName, int *pReturnCode);
+
+
+typedef IBaseInterface* (*InstantiateInterfaceFn)();
+
+
+// Used internally to register classes.
+class InterfaceReg
+{
+public:
+				InterfaceReg(InstantiateInterfaceFn fn, const char *pName);
+
+public:
+
+	InstantiateInterfaceFn	m_CreateFn;
+	const char				*m_pName;
+
+	InterfaceReg			*m_pNext; // For the global list.
+	static InterfaceReg		*s_pInterfaceRegs;
+};
+
+
+// Use this to expose an interface that can have multiple instances.
+// e.g.:
+// EXPOSE_INTERFACE( CInterfaceImp, IInterface, "MyInterface001" )
+// This will expose a class called CInterfaceImp that implements IInterface (a pure class)
+// clients can receive a pointer to this class by calling CreateInterface( "MyInterface001" )
+//
+// In practice, the shared header file defines the interface (IInterface) and version name ("MyInterface001")
+// so that each component can use these names/vtables to communicate
+//
+// A single class can support multiple interfaces through multiple inheritance
+//
+#define EXPOSE_INTERFACE_FN(functionName, interfaceName, versionName) \
+	static InterfaceReg __g_Create##className##_reg(functionName, versionName);
+
+#define EXPOSE_INTERFACE(className, interfaceName, versionName) \
+	static IBaseInterface* __Create##className##_interface() {return (interfaceName *)new className;}\
+	static InterfaceReg __g_Create##className##_reg(__Create##className##_interface, versionName );
+
+// Use this to expose a singleton interface with a global variable you've created.
+#define EXPOSE_SINGLE_INTERFACE_GLOBALVAR(className, interfaceName, versionName, globalVarName) \
+	static IBaseInterface* __Create##className##interfaceName##_interface() {return (interfaceName *)&globalVarName;}\
+	static InterfaceReg __g_Create##className##interfaceName##_reg(__Create##className##interfaceName##_interface, versionName);
+
+// Use this to expose a singleton interface. This creates the global variable for you automatically.
+#define EXPOSE_SINGLE_INTERFACE(className, interfaceName, versionName) \
+	static className __g_##className##_singleton;\
+	EXPOSE_SINGLE_INTERFACE_GLOBALVAR(className, interfaceName, versionName, __g_##className##_singleton)
+
+
+#ifdef WIN32
+	#define EXPORT_FUNCTION __declspec(dllexport)
+#else
+	#define EXPORT_FUNCTION
+#endif
+
+
+// This function is automatically exported and allows you to access any interfaces exposed with the above macros.
+// if pReturnCode is set, it will return one of the following values
+// extend this for other error conditions/code
+enum 
+{
+	IFACE_OK = 0,
+	IFACE_FAILED
+};
+
+
+extern "C"
+{
+	EXPORT_FUNCTION IBaseInterface* CreateInterface(const char *pName, int *pReturnCode);
+};
+
+
+// Handle to an interface (HInterfaceModule_t* is just there for type safety).
+typedef struct HInterfaceModule_t* HINTERFACEMODULE;
+
+
+// Use these to load and unload a module.
+extern HINTERFACEMODULE		Sys_LoadModule(const char *pModuleName);
+extern void					Sys_FreeModule(HINTERFACEMODULE hModule);
+
+// Use these to get the factory function from either a loaded module or the current module.
+extern CreateInterfaceFn	Sys_GetFactory( HINTERFACEMODULE hModule );
+extern CreateInterfaceFn	Sys_GetFactoryThis( void );
+
+#endif // __cplusplus
+
+#endif
+
+
+
diff --git a/sdk/hlsdk/common/ivoicetweak.h b/sdk/hlsdk/common/ivoicetweak.h
new file mode 100644
index 0000000..c5f3402
--- /dev/null
+++ b/sdk/hlsdk/common/ivoicetweak.h
@@ -0,0 +1,37 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef IVOICETWEAK_H
+#define IVOICETWEAK_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+// These provide access to the voice controls.
+typedef enum
+{
+	MicrophoneVolume=0,			// values 0-1.
+	OtherSpeakerScale			// values 0-1. Scales how loud other players are.
+} VoiceTweakControl;
+
+
+typedef struct IVoiceTweak_s
+{
+	// These turn voice tweak mode on and off. While in voice tweak mode, the user's voice is echoed back
+	// without sending to the server. 
+	int				(*StartVoiceTweakMode)();	// Returns 0 on error.
+	void			(*EndVoiceTweakMode)();
+	
+	// Get/set control values.
+	void			(*SetControlFloat)(VoiceTweakControl iControl, float value);
+	float			(*GetControlFloat)(VoiceTweakControl iControl);
+} IVoiceTweak;
+
+
+#endif // IVOICETWEAK_H
diff --git a/sdk/hlsdk/common/mathlib.h b/sdk/hlsdk/common/mathlib.h
new file mode 100644
index 0000000..908e631
--- /dev/null
+++ b/sdk/hlsdk/common/mathlib.h
@@ -0,0 +1,156 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+// mathlib.h
+
+typedef float vec_t;
+typedef vec_t vec3_t[3];
+typedef vec_t vec4_t[4];	// x,y,z,w
+typedef vec_t vec5_t[5];
+
+typedef short vec_s_t;
+typedef vec_s_t vec3s_t[3];
+typedef vec_s_t vec4s_t[4];	// x,y,z,w
+typedef vec_s_t vec5s_t[5];
+
+typedef	int	fixed4_t;
+typedef	int	fixed8_t;
+typedef	int	fixed16_t;
+
+#ifndef M_PI
+#define M_PI		3.14159265358979323846	// matches value in gcc v2 math.h
+#endif
+
+struct mplane_s;
+
+extern vec3_t vec3_origin;
+extern	int nanmask;
+
+#define	IS_NAN(x) (((*(int *)&x)&nanmask)==nanmask)
+
+#ifndef VECTOR_H
+	#define DotProduct(x,y) ((x)[0]*(y)[0]+(x)[1]*(y)[1]+(x)[2]*(y)[2])
+#endif
+
+#define VectorSubtract(a,b,c) {(c)[0]=(a)[0]-(b)[0];(c)[1]=(a)[1]-(b)[1];(c)[2]=(a)[2]-(b)[2];}
+#define VectorAdd(a,b,c) {(c)[0]=(a)[0]+(b)[0];(c)[1]=(a)[1]+(b)[1];(c)[2]=(a)[2]+(b)[2];}
+#define VectorCopy(a,b) {(b)[0]=(a)[0];(b)[1]=(a)[1];(b)[2]=(a)[2];}
+#define VectorClear(a) {(a)[0]=0.0;(a)[1]=0.0;(a)[2]=0.0;}
+
+void VectorMA (const vec3_t veca, float scale, const vec3_t vecb, vec3_t vecc);
+
+vec_t _DotProduct (vec3_t v1, vec3_t v2);
+void _VectorSubtract (vec3_t veca, vec3_t vecb, vec3_t out);
+void _VectorAdd (vec3_t veca, vec3_t vecb, vec3_t out);
+void _VectorCopy (vec3_t in, vec3_t out);
+
+int VectorCompare (const vec3_t v1, const vec3_t v2);
+float Length (const vec3_t v);
+void CrossProduct (const vec3_t v1, const vec3_t v2, vec3_t cross);
+float VectorNormalize (vec3_t v);		// returns vector length
+void VectorInverse (vec3_t v);
+void VectorScale (const vec3_t in, vec_t scale, vec3_t out);
+int Q_log2(int val);
+
+void R_ConcatRotations (float in1[3][3], float in2[3][3], float out[3][3]);
+void R_ConcatTransforms (float in1[3][4], float in2[3][4], float out[3][4]);
+
+// Here are some "manual" INLINE routines for doing floating point to integer conversions
+extern short new_cw, old_cw;
+
+typedef union DLONG {
+	int		i[2];
+	double	d;
+	float	f;
+	} DLONG;
+
+extern DLONG	dlong;
+
+#ifdef _WIN32
+void __inline set_fpu_cw(void)
+{
+_asm	
+	{		wait
+			fnstcw	old_cw
+			wait
+			mov		ax, word ptr old_cw
+			or		ah, 0xc
+			mov		word ptr new_cw,ax
+			fldcw	new_cw
+	}
+}
+
+int __inline quick_ftol(float f)
+{
+	_asm {
+		// Assumes that we are already in chop mode, and only need a 32-bit int
+		fld		DWORD PTR f
+		fistp	DWORD PTR dlong
+	}
+	return dlong.i[0];
+}
+
+void __inline restore_fpu_cw(void)
+{
+	_asm	fldcw	old_cw
+}
+#else
+#define set_fpu_cw() /* */
+#define quick_ftol(f) ftol(f)
+#define restore_fpu_cw() /* */
+#endif
+
+void FloorDivMod (double numer, double denom, int *quotient,
+		int *rem);
+fixed16_t Invert24To16(fixed16_t val);
+int GreatestCommonDivisor (int i1, int i2);
+
+void AngleVectors (const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up);
+void AngleVectorsTranspose (const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up);
+#define AngleIVectors	AngleVectorsTranspose
+
+void AngleMatrix (const vec3_t angles, float (*matrix)[4] );
+void AngleIMatrix (const vec3_t angles, float (*matrix)[4] );
+void VectorTransform (const vec3_t in1, float in2[3][4], vec3_t out);
+
+void NormalizeAngles( vec3_t angles );
+void InterpolateAngles( vec3_t start, vec3_t end, vec3_t output, float frac );
+float AngleBetweenVectors( const vec3_t v1, const vec3_t v2 );
+
+
+void VectorMatrix( vec3_t forward, vec3_t right, vec3_t up);
+void VectorAngles( const vec3_t forward, vec3_t angles );
+
+int InvertMatrix( const float * m, float *out );
+
+int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct mplane_s *plane);
+float	anglemod(float a);
+
+
+
+#define BOX_ON_PLANE_SIDE(emins, emaxs, p)	\
+	(((p)->type < 3)?						\
+	(										\
+		((p)->dist <= (emins)[(p)->type])?	\
+			1								\
+		:									\
+		(									\
+			((p)->dist >= (emaxs)[(p)->type])?\
+				2							\
+			:								\
+				3							\
+		)									\
+	)										\
+	:										\
+		BoxOnPlaneSide( (emins), (emaxs), (p)))
diff --git a/sdk/hlsdk/common/net_api.h b/sdk/hlsdk/common/net_api.h
new file mode 100644
index 0000000..df86cca
--- /dev/null
+++ b/sdk/hlsdk/common/net_api.h
@@ -0,0 +1,101 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#if !defined( NET_APIH )
+#define NET_APIH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#if !defined ( NETADRH )
+#include "netadr.h"
+#endif
+
+#define NETAPI_REQUEST_SERVERLIST	( 0 )  // Doesn't need a remote address
+#define NETAPI_REQUEST_PING			( 1 )
+#define NETAPI_REQUEST_RULES		( 2 )
+#define NETAPI_REQUEST_PLAYERS		( 3 )
+#define NETAPI_REQUEST_DETAILS		( 4 )
+
+// Set this flag for things like broadcast requests, etc. where the engine should not
+//  kill the request hook after receiving the first response
+#define FNETAPI_MULTIPLE_RESPONSE ( 1<<0 )
+
+typedef void ( *net_api_response_func_t ) ( struct net_response_s *response );
+
+#define NET_SUCCESS						( 0 )
+#define NET_ERROR_TIMEOUT				( 1<<0 )
+#define NET_ERROR_PROTO_UNSUPPORTED		( 1<<1 )
+#define NET_ERROR_UNDEFINED				( 1<<2 )
+
+typedef struct net_adrlist_s
+{
+	struct net_adrlist_s	*next;
+	netadr_t				remote_address;
+} net_adrlist_t;
+
+typedef struct net_response_s
+{
+	// NET_SUCCESS or an error code
+	int			error;
+
+	// Context ID
+	int			context;
+	// Type
+	int			type;
+
+	// Server that is responding to the request
+	netadr_t	remote_address;
+
+	// Response RTT ping time
+	double		ping;
+	// Key/Value pair string ( separated by backlash \ characters )
+	// WARNING:  You must copy this buffer in the callback function, because it is freed
+	//  by the engine right after the call!!!!
+	// ALSO:  For NETAPI_REQUEST_SERVERLIST requests, this will be a pointer to a linked list of net_adrlist_t's
+	void		*response;
+} net_response_t;
+
+typedef struct net_status_s
+{
+		// Connected to remote server?  1 == yes, 0 otherwise
+	int			connected; 
+	// Client's IP address
+	netadr_t	local_address;
+	// Address of remote server
+	netadr_t	remote_address;
+	// Packet Loss ( as a percentage )
+	int			packet_loss;
+	// Latency, in seconds ( multiply by 1000.0 to get milliseconds )
+	double		latency;
+	// Connection time, in seconds
+	double		connection_time;
+	// Rate setting ( for incoming data )
+	double		rate;
+} net_status_t;
+
+typedef struct net_api_s
+{
+	// APIs
+	void		( *InitNetworking )( void );
+	void		( *Status ) ( struct net_status_s *status );
+	void		( *SendRequest) ( int context, int request, int flags, double timeout, struct netadr_s *remote_address, net_api_response_func_t response );
+	void		( *CancelRequest ) ( int context );
+	void		( *CancelAllRequests ) ( void );
+	char		*( *AdrToString ) ( struct netadr_s *a );
+	int			( *CompareAdr ) ( struct netadr_s *a, struct netadr_s *b );
+	int			( *StringToAdr ) ( char *s, struct netadr_s *a );
+	const char *( *ValueForKey ) ( const char *s, const char *key );
+	void		( *RemoveKey ) ( char *s, const char *key );
+	void		( *SetValueForKey ) (char *s, const char *key, const char *value, int maxsize );
+} net_api_t;
+
+extern net_api_t netapi;
+
+#endif // NET_APIH
diff --git a/sdk/hlsdk/common/netadr.h b/sdk/hlsdk/common/netadr.h
new file mode 100644
index 0000000..f320f93
--- /dev/null
+++ b/sdk/hlsdk/common/netadr.h
@@ -0,0 +1,42 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+// netadr.h
+#ifndef NETADR_H
+#define NETADR_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef enum
+{
+	NA_UNUSED,
+	NA_LOOPBACK,
+	NA_BROADCAST,
+	NA_IP,
+	NA_IPX,
+	NA_BROADCAST_IPX,
+} netadrtype_t;
+
+typedef struct netadr_s
+{
+	netadrtype_t	type;
+	unsigned char	ip[4];
+	unsigned char	ipx[10];
+	unsigned short	port;
+} netadr_t;
+
+#endif // NETADR_H
diff --git a/sdk/hlsdk/common/nowin.h b/sdk/hlsdk/common/nowin.h
new file mode 100644
index 0000000..fa9863a
--- /dev/null
+++ b/sdk/hlsdk/common/nowin.h
@@ -0,0 +1,15 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef INC_NOWIN_H
+#define INC_NOWIN_H
+#ifndef _WIN32
+
+#include <unistd.h>
+
+#endif //!_WIN32
+#endif //INC_NOWIN_H
diff --git a/sdk/hlsdk/common/particledef.h b/sdk/hlsdk/common/particledef.h
new file mode 100644
index 0000000..66fc920
--- /dev/null
+++ b/sdk/hlsdk/common/particledef.h
@@ -0,0 +1,59 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( PARTICLEDEFH )
+#define PARTICLEDEFH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef enum {
+	pt_static, 
+	pt_grav,
+	pt_slowgrav,
+	pt_fire,
+	pt_explode,
+	pt_explode2,
+	pt_blob,
+	pt_blob2,
+	pt_vox_slowgrav,
+	pt_vox_grav,
+	pt_clientcustom   // Must have callback function specified
+} ptype_t;
+
+// !!! if this is changed, it must be changed in d_ifacea.h too !!!
+typedef struct particle_s
+{
+// driver-usable fields
+	vec3_t		org;
+	short		color;
+	short		packedColor;
+// drivers never touch the following fields
+	struct particle_s	*next;
+	vec3_t		vel;
+	float		ramp;
+	float		die;
+	ptype_t		type;
+	void		(*deathfunc)( struct particle_s *particle );
+
+	// for pt_clientcusttom, we'll call this function each frame
+	void		(*callback)( struct particle_s *particle, float frametime );
+	
+	// For deathfunc, etc.
+	unsigned char context;
+} particle_t;
+
+#endif
diff --git a/sdk/hlsdk/common/pmtrace.h b/sdk/hlsdk/common/pmtrace.h
new file mode 100644
index 0000000..24eb062
--- /dev/null
+++ b/sdk/hlsdk/common/pmtrace.h
@@ -0,0 +1,45 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( PMTRACEH )
+#define PMTRACEH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef struct
+{
+	vec3_t	normal;
+	float	dist;
+} pmplane_t;
+
+typedef struct pmtrace_s pmtrace_t;
+
+struct pmtrace_s
+{
+	qboolean	allsolid;	      // if true, plane is not valid
+	qboolean	startsolid;	      // if true, the initial point was in a solid area
+	qboolean	inopen, inwater;  // End point is in empty space or in water
+	float		fraction;		  // time completed, 1.0 = didn't hit anything
+	vec3_t		endpos;			  // final position
+	pmplane_t	plane;		      // surface normal at impact
+	int			ent;			  // entity at impact
+	vec3_t      deltavelocity;    // Change in player's velocity caused by impact.  
+								  // Only run on server.
+	int         hitgroup;
+};
+
+#endif
diff --git a/sdk/hlsdk/common/qfont.h b/sdk/hlsdk/common/qfont.h
new file mode 100644
index 0000000..3866030
--- /dev/null
+++ b/sdk/hlsdk/common/qfont.h
@@ -0,0 +1,42 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( QFONTH )
+#define QFONTH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+// Font stuff
+
+#define NUM_GLYPHS 256
+
+typedef struct
+{
+	short startoffset;
+	short charwidth;
+} charinfo;
+
+typedef struct qfont_s
+{
+	int 		width, height;
+	int			rowcount;
+	int			rowheight;
+	charinfo	fontinfo[ NUM_GLYPHS ];
+	byte 		data[4];
+} qfont_t;
+
+#endif // qfont.h
diff --git a/sdk/hlsdk/common/r_efx.h b/sdk/hlsdk/common/r_efx.h
new file mode 100644
index 0000000..3b9aaf5
--- /dev/null
+++ b/sdk/hlsdk/common/r_efx.h
@@ -0,0 +1,199 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined ( R_EFXH )
+#define R_EFXH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+// particle_t
+#if !defined( PARTICLEDEFH )  
+#include "particledef.h"
+#endif
+
+// BEAM
+#if !defined( BEAMDEFH )
+#include "beamdef.h"
+#endif
+
+// dlight_t
+#if !defined ( DLIGHTH )
+#include "dlight.h"
+#endif
+
+// cl_entity_t
+#if !defined( CL_ENTITYH )
+#include "cl_entity.h"
+#endif
+
+/*
+// FOR REFERENCE, These are the built-in tracer colors.  Note, color 4 is the one
+//  that uses the tracerred/tracergreen/tracerblue and traceralpha cvar settings
+color24 gTracerColors[] =
+{
+	{ 255, 255, 255 },		// White
+	{ 255, 0, 0 },			// Red
+	{ 0, 255, 0 },			// Green
+	{ 0, 0, 255 },			// Blue
+	{ 0, 0, 0 },			// Tracer default, filled in from cvars, etc.
+	{ 255, 167, 17 },		// Yellow-orange sparks
+	{ 255, 130, 90 },		// Yellowish streaks (garg)
+	{ 55, 60, 144 },		// Blue egon streak
+	{ 255, 130, 90 },		// More Yellowish streaks (garg)
+	{ 255, 140, 90 },		// More Yellowish streaks (garg)
+	{ 200, 130, 90 },		// More red streaks (garg)
+	{ 255, 120, 70 },		// Darker red streaks (garg)
+};
+*/
+
+// Temporary entity array
+#define TENTPRIORITY_LOW	0
+#define TENTPRIORITY_HIGH	1
+
+// TEMPENTITY flags
+#define	FTENT_NONE				0x00000000
+#define	FTENT_SINEWAVE			0x00000001
+#define	FTENT_GRAVITY			0x00000002
+#define FTENT_ROTATE			0x00000004
+#define	FTENT_SLOWGRAVITY		0x00000008
+#define FTENT_SMOKETRAIL		0x00000010
+#define FTENT_COLLIDEWORLD		0x00000020
+#define FTENT_FLICKER			0x00000040
+#define FTENT_FADEOUT			0x00000080
+#define FTENT_SPRANIMATE		0x00000100
+#define FTENT_HITSOUND			0x00000200
+#define FTENT_SPIRAL			0x00000400
+#define FTENT_SPRCYCLE			0x00000800
+#define FTENT_COLLIDEALL		0x00001000 // will collide with world and slideboxes
+#define FTENT_PERSIST			0x00002000 // tent is not removed when unable to draw 
+#define FTENT_COLLIDEKILL		0x00004000 // tent is removed upon collision with anything
+#define FTENT_PLYRATTACHMENT	0x00008000 // tent is attached to a player (owner)
+#define FTENT_SPRANIMATELOOP	0x00010000 // animating sprite doesn't die when last frame is displayed
+#define FTENT_SPARKSHOWER		0x00020000
+#define FTENT_NOMODEL			0x00040000 // Doesn't have a model, never try to draw ( it just triggers other things )
+#define FTENT_CLIENTCUSTOM		0x00080000 // Must specify callback.  Callback function is responsible for killing tempent and updating fields ( unless other flags specify how to do things )
+
+typedef struct tempent_s	TEMPENTITY;
+typedef struct tempent_s
+{
+	int			flags;
+	float		die;
+	float		frameMax;
+	float		x;
+	float		y;
+	float		z;
+	float		fadeSpeed;
+	float		bounceFactor;
+	int			hitSound;
+	void		( *hitcallback )	( struct tempent_s *ent, struct pmtrace_s *ptr );
+	void		( *callback )		( struct tempent_s *ent, float frametime, float currenttime );
+	TEMPENTITY	*next;
+	int			priority;
+	short		clientIndex;	// if attached, this is the index of the client to stick to
+								// if COLLIDEALL, this is the index of the client to ignore
+								// TENTS with FTENT_PLYRATTACHMENT MUST set the clientindex! 
+
+	vec3_t		tentOffset;		// if attached, client origin + tentOffset = tent origin.
+	cl_entity_t	entity;
+
+	// baseline.origin		- velocity
+	// baseline.renderamt	- starting fadeout intensity
+	// baseline.angles		- angle velocity
+} TEMPENTITY;
+
+typedef struct efx_api_s efx_api_t;
+
+struct efx_api_s
+{
+	particle_t  *( *R_AllocParticle )			( void ( *callback ) ( struct particle_s *particle, float frametime ) );
+	void		( *R_BlobExplosion )			( float * org );
+	void		( *R_Blood )					( float * org, float * dir, int pcolor, int speed );
+	void		( *R_BloodSprite )				( float * org, int colorindex, int modelIndex, int modelIndex2, float size );
+	void		( *R_BloodStream )				( float * org, float * dir, int pcolor, int speed );
+	void		( *R_BreakModel )				( float *pos, float *size, float *dir, float random, float life, int count, int modelIndex, char flags );
+	void		( *R_Bubbles )					( float * mins, float * maxs, float height, int modelIndex, int count, float speed );
+	void		( *R_BubbleTrail )				( float * start, float * end, float height, int modelIndex, int count, float speed );
+	void		( *R_BulletImpactParticles )	( float * pos );
+	void		( *R_EntityParticles )			( struct cl_entity_s *ent );
+	void		( *R_Explosion )				( float *pos, int model, float scale, float framerate, int flags );
+	void		( *R_FizzEffect )				( struct cl_entity_s *pent, int modelIndex, int density );
+	void		( *R_FireField ) 				( float * org, int radius, int modelIndex, int count, int flags, float life );
+	void		( *R_FlickerParticles )			( float * org );
+	void		( *R_FunnelSprite )				( float *org, int modelIndex, int reverse );
+	void		( *R_Implosion )				( float * end, float radius, int count, float life );
+	void		( *R_LargeFunnel )				( float * org, int reverse );
+	void		( *R_LavaSplash )				( float * org );
+	void		( *R_MultiGunshot )				( float * org, float * dir, float * noise, int count, int decalCount, int *decalIndices );
+	void		( *R_MuzzleFlash )				( float *pos1, int type );
+	void		( *R_ParticleBox )				( float *mins, float *maxs, unsigned char r, unsigned char g, unsigned char b, float life );
+	void		( *R_ParticleBurst )			( float * pos, int size, int color, float life );
+	void		( *R_ParticleExplosion )		( float * org );
+	void		( *R_ParticleExplosion2 )		( float * org, int colorStart, int colorLength );
+	void		( *R_ParticleLine )				( float * start, float *end, unsigned char r, unsigned char g, unsigned char b, float life );
+	void		( *R_PlayerSprites )			( int client, int modelIndex, int count, int size );
+	void		( *R_Projectile )				( float * origin, float * velocity, int modelIndex, int life, int owner, void (*hitcallback)( struct tempent_s *ent, struct pmtrace_s *ptr ) );
+	void		( *R_RicochetSound )			( float * pos );
+	void		( *R_RicochetSprite )			( float *pos, struct model_s *pmodel, float duration, float scale );
+	void		( *R_RocketFlare )				( float *pos );
+	void		( *R_RocketTrail )				( float * start, float * end, int type );
+	void		( *R_RunParticleEffect )		( float * org, float * dir, int color, int count );
+	void		( *R_ShowLine )					( float * start, float * end );
+	void		( *R_SparkEffect )				( float *pos, int count, int velocityMin, int velocityMax );
+	void		( *R_SparkShower )				( float *pos );
+	void		( *R_SparkStreaks )				( float * pos, int count, int velocityMin, int velocityMax );
+	void		( *R_Spray )					( float * pos, float * dir, int modelIndex, int count, int speed, int spread, int rendermode );
+	void		( *R_Sprite_Explode )			( TEMPENTITY *pTemp, float scale, int flags );
+	void		( *R_Sprite_Smoke )				( TEMPENTITY *pTemp, float scale );
+	void		( *R_Sprite_Spray )				( float * pos, float * dir, int modelIndex, int count, int speed, int iRand );
+	void		( *R_Sprite_Trail )				( int type, float * start, float * end, int modelIndex, int count, float life, float size, float amplitude, int renderamt, float speed );
+	void		( *R_Sprite_WallPuff )			( TEMPENTITY *pTemp, float scale );
+	void		( *R_StreakSplash )				( float * pos, float * dir, int color, int count, float speed, int velocityMin, int velocityMax );
+	void		( *R_TracerEffect )				( float * start, float * end );
+	void		( *R_UserTracerParticle )		( float * org, float * vel, float life, int colorIndex, float length, unsigned char deathcontext, void ( *deathfunc)( struct particle_s *particle ) );
+	particle_t *( *R_TracerParticles )			( float * org, float * vel, float life );
+	void		( *R_TeleportSplash )			( float * org );
+	void		( *R_TempSphereModel )			( float *pos, float speed, float life, int count, int modelIndex );
+	TEMPENTITY	*( *R_TempModel )				( float *pos, float *dir, float *angles, float life, int modelIndex, int soundtype );
+	TEMPENTITY	*( *R_DefaultSprite )			( float *pos, int spriteIndex, float framerate );
+	TEMPENTITY	*( *R_TempSprite )				( float *pos, float *dir, float scale, int modelIndex, int rendermode, int renderfx, float a, float life, int flags );
+	int			( *Draw_DecalIndex )			( int id );
+	int			( *Draw_DecalIndexFromName )	( char *name );
+	void		( *R_DecalShoot )				( int textureIndex, int entity, int modelIndex, float * position, int flags );
+	void		( *R_AttachTentToPlayer )		( int client, int modelIndex, float zoffset, float life );
+	void		( *R_KillAttachedTents )		( int client );
+	BEAM		*( *R_BeamCirclePoints )		( int type, float * start, float * end, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
+	BEAM		*( *R_BeamEntPoint )			( int startEnt, float * end, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
+	BEAM		*( *R_BeamEnts )				( int startEnt, int endEnt, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
+	BEAM		*( *R_BeamFollow )				( int startEnt, int modelIndex, float life, float width, float r, float g, float b, float brightness );
+	void		( *R_BeamKill )					( int deadEntity );
+	BEAM		*( *R_BeamLightning )			( float * start, float * end, int modelIndex, float life, float width, float amplitude, float brightness, float speed );
+	BEAM		*( *R_BeamPoints )				( float * start, float * end, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
+	BEAM		*( *R_BeamRing )				( int startEnt, int endEnt, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
+	dlight_t	*( *CL_AllocDlight )			( int key );
+	dlight_t	*( *CL_AllocElight )			( int key );
+	TEMPENTITY	*( *CL_TempEntAlloc )			( float * org, struct model_s *model );
+	TEMPENTITY	*( *CL_TempEntAllocNoModel )	( float * org );
+	TEMPENTITY	*( *CL_TempEntAllocHigh )		( float * org, struct model_s *model );
+	TEMPENTITY	*( *CL_TentEntAllocCustom )		( float *origin, struct model_s *model, int high, void ( *callback ) ( struct tempent_s *ent, float frametime, float currenttime ) );
+	void		( *R_GetPackedColor )			( short *packed, short color );
+	short		( *R_LookupColor )				( unsigned char r, unsigned char g, unsigned char b );
+	void		( *R_DecalRemoveAll )			( int textureIndex ); //textureIndex points to the decal index in the array, not the actual texture index.
+};
+
+extern efx_api_t efx;
+
+#endif
diff --git a/sdk/hlsdk/common/r_studioint.h b/sdk/hlsdk/common/r_studioint.h
new file mode 100644
index 0000000..bcf2be7
--- /dev/null
+++ b/sdk/hlsdk/common/r_studioint.h
@@ -0,0 +1,149 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#if !defined( R_STUDIOINT_H )
+#define R_STUDIOINT_H
+#if defined( _WIN32 )
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#define STUDIO_INTERFACE_VERSION 1
+
+typedef struct engine_studio_api_s
+{
+	// Allocate number*size bytes and zero it
+	void			*( *Mem_Calloc )				( int number, size_t size );
+	// Check to see if pointer is in the cache
+	void			*( *Cache_Check )				( struct cache_user_s *c );
+	// Load file into cache ( can be swapped out on demand )
+	void			( *LoadCacheFile )				( char *path, struct cache_user_s *cu );
+	// Retrieve model pointer for the named model
+	struct model_s	*( *Mod_ForName )				( const char *name, int crash_if_missing );
+	// Retrieve pointer to studio model data block from a model
+	void			*( *Mod_Extradata )				( struct model_s *mod );
+	// Retrieve indexed model from client side model precache list
+	struct model_s	*( *GetModelByIndex )			( int index );
+	// Get entity that is set for rendering
+	struct cl_entity_s * ( *GetCurrentEntity )		( void );
+	// Get referenced player_info_t
+	struct player_info_s *( *PlayerInfo )			( int index );
+	// Get most recently received player state data from network system
+	struct entity_state_s *( *GetPlayerState )		( int index );
+	// Get viewentity
+	struct cl_entity_s * ( *GetViewEntity )			( void );
+	// Get current frame count, and last two timestampes on client
+	void			( *GetTimes )					( int *framecount, double *current, double *old );
+	// Get a pointer to a cvar by name
+	struct cvar_s	*( *GetCvar )					( const char *name );
+	// Get current render origin and view vectors ( up, right and vpn )
+	void			( *GetViewInfo )				( float *origin, float *upv, float *rightv, float *vpnv );
+	// Get sprite model used for applying chrome effect
+	struct model_s	*( *GetChromeSprite )			( void );
+	// Get model counters so we can incement instrumentation
+	void			( *GetModelCounters )			( int **s, int **a );
+	// Get software scaling coefficients
+	void			( *GetAliasScale )				( float *x, float *y );
+
+	// Get bone, light, alias, and rotation matrices
+	float			****( *StudioGetBoneTransform ) ( void );
+	float			****( *StudioGetLightTransform )( void );
+	float			***( *StudioGetAliasTransform ) ( void );
+	float			***( *StudioGetRotationMatrix ) ( void );
+
+	// Set up body part, and get submodel pointers
+	void			( *StudioSetupModel )			( int bodypart, void **ppbodypart, void **ppsubmodel );
+	// Check if entity's bbox is in the view frustum
+	int				( *StudioCheckBBox )			( void );
+	// Apply lighting effects to model
+	void			( *StudioDynamicLight )			( struct cl_entity_s *ent, struct alight_s *plight );
+	void			( *StudioEntityLight )			( struct alight_s *plight );
+	void			( *StudioSetupLighting )		( struct alight_s *plighting );
+
+	// Draw mesh vertices
+	void			( *StudioDrawPoints )			( void );
+
+	// Draw hulls around bones
+	void			( *StudioDrawHulls )			( void );
+	// Draw bbox around studio models
+	void			( *StudioDrawAbsBBox )			( void );
+	// Draws bones
+	void			( *StudioDrawBones )			( void );
+	// Loads in appropriate texture for model
+	void			( *StudioSetupSkin )			( void *ptexturehdr, int index );
+	// Sets up for remapped colors
+	void			( *StudioSetRemapColors )		( int top, int bottom );
+	// Set's player model and returns model pointer
+	struct model_s	*( *SetupPlayerModel )			( int index );
+	// Fires any events embedded in animation
+	void			( *StudioClientEvents )			( void );
+	// Retrieve/set forced render effects flags
+	int				( *GetForceFaceFlags )			( void );
+	void			( *SetForceFaceFlags )			( int flags );
+	// Tell engine the value of the studio model header
+	void			( *StudioSetHeader )			( void *header );
+	// Tell engine which model_t * is being renderered
+	void			( *SetRenderModel )				( struct model_s *model );
+
+	// Final state setup and restore for rendering
+	void			( *SetupRenderer )				( int rendermode );
+	void			( *RestoreRenderer )			( void );
+
+	// Set render origin for applying chrome effect
+	void			( *SetChromeOrigin )			( void );
+
+	// True if using D3D/OpenGL
+	int				( *IsHardware )					( void );
+	
+	// Only called by hardware interface
+	void			( *GL_StudioDrawShadow )		( void );
+	void			( *GL_SetRenderMode )			( int mode );
+} engine_studio_api_t;
+
+typedef struct server_studio_api_s
+{
+	// Allocate number*size bytes and zero it
+	void			*( *Mem_Calloc )				( int number, size_t size );
+	// Check to see if pointer is in the cache
+	void			*( *Cache_Check )				( struct cache_user_s *c );
+	// Load file into cache ( can be swapped out on demand )
+	void			( *LoadCacheFile )				( char *path, struct cache_user_s *cu );
+	// Retrieve pointer to studio model data block from a model
+	void			*( *Mod_Extradata )				( struct model_s *mod );
+} server_studio_api_t;
+
+
+// client blending
+typedef struct r_studio_interface_s
+{
+	int				version;
+	int				( *StudioDrawModel	)			( int flags );
+	int				( *StudioDrawPlayer	)			( int flags, struct entity_state_s *pplayer );
+} r_studio_interface_t;
+
+extern r_studio_interface_t *pStudioAPI;
+
+// server blending
+#define SV_BLENDING_INTERFACE_VERSION 1
+
+typedef struct sv_blending_interface_s
+{
+	int	version;
+
+	void	( *SV_StudioSetupBones )( struct model_s *pModel, 
+					float frame,
+					int sequence,
+					const vec3_t angles,
+					const vec3_t origin,
+					const byte *pcontroller,
+					const byte *pblending,
+					int iBone,
+					const edict_t *pEdict );
+} sv_blending_interface_t;
+
+#endif // R_STUDIOINT_H
diff --git a/sdk/hlsdk/common/ref_params.h b/sdk/hlsdk/common/ref_params.h
new file mode 100644
index 0000000..90eb03f
--- /dev/null
+++ b/sdk/hlsdk/common/ref_params.h
@@ -0,0 +1,75 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( REF_PARAMSH )
+#define REF_PARAMSH
+
+typedef struct ref_params_s
+{
+	// Output
+	float	vieworg[3];
+	float	viewangles[3];
+
+	float	forward[3];
+	float	right[3];
+	float   up[3];
+
+	// Client frametime;
+	float	frametime;
+	// Client time
+	float	time;
+
+	// Misc
+	int		intermission;
+	int		paused;
+	int		spectator;
+	int		onground;
+	int		waterlevel;
+
+	float	simvel[3];
+	float	simorg[3];
+
+	float	viewheight[3];
+	float	idealpitch;
+
+	float	cl_viewangles[3];
+
+	int		health;
+	float	crosshairangle[3];
+	float	viewsize;
+
+	float	punchangle[3];
+	int		maxclients;
+	int		viewentity;
+	int		playernum;
+	int		max_entities;
+	int		demoplayback;
+	int		hardware;
+
+	int		smoothing;
+
+	// Last issued usercmd
+	struct usercmd_s *cmd;
+
+	// Movevars
+	struct movevars_s *movevars;
+
+	int		viewport[4];		// the viewport coordinates x ,y , width, height
+
+	int		nextView;			// the renderer calls ClientDLL_CalcRefdef() and Renderview
+								// so long in cycles until this value is 0 (multiple views)
+	int		onlyClientDraw;		// if !=0 nothing is drawn by the engine except clientDraw functions
+} ref_params_t;
+
+#endif // !REF_PARAMSH
diff --git a/sdk/hlsdk/common/screenfade.h b/sdk/hlsdk/common/screenfade.h
new file mode 100644
index 0000000..11223df
--- /dev/null
+++ b/sdk/hlsdk/common/screenfade.h
@@ -0,0 +1,26 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#if !defined( SCREENFADEH )
+#define SCREENFADEH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef struct screenfade_s
+{
+	float		fadeSpeed;		// How fast to fade (tics / second) (+ fade in, - fade out)
+	float		fadeEnd;		// When the fading hits maximum
+	float		fadeTotalEnd;	// Total End Time of the fade (used for FFADE_OUT)
+	float		fadeReset;		// When to reset to not fading (for fadeout and hold)
+	byte		fader, fadeg, fadeb, fadealpha;	// Fade color
+	int			fadeFlags;		// Fading flags
+} screenfade_t;
+
+#endif // !SCREENFADEH
diff --git a/sdk/hlsdk/common/studio_event.h b/sdk/hlsdk/common/studio_event.h
new file mode 100644
index 0000000..0756c65
--- /dev/null
+++ b/sdk/hlsdk/common/studio_event.h
@@ -0,0 +1,31 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( STUDIO_EVENTH )
+#define STUDIO_EVENTH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef struct mstudioevent_s
+{
+	int 				frame;
+	int					event;
+	int					type;
+	char				options[64];
+} mstudioevent_t;
+
+#endif // STUDIO_EVENTH
diff --git a/sdk/hlsdk/common/triangleapi.h b/sdk/hlsdk/common/triangleapi.h
new file mode 100644
index 0000000..e984cf8
--- /dev/null
+++ b/sdk/hlsdk/common/triangleapi.h
@@ -0,0 +1,61 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( TRIANGLEAPIH )
+#define TRIANGLEAPIH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef enum 
+{
+	TRI_FRONT = 0,
+	TRI_NONE = 1,
+} TRICULLSTYLE;
+
+#define TRI_API_VERSION		1
+
+#define TRI_TRIANGLES		0
+#define TRI_TRIANGLE_FAN	1
+#define TRI_QUADS			2
+#define TRI_POLYGON			3
+#define TRI_LINES			4	
+#define TRI_TRIANGLE_STRIP	5
+#define TRI_QUAD_STRIP		6
+
+typedef struct triangleapi_s
+{
+	int			version;
+
+	void		( *RenderMode )( int mode );
+	void		( *Begin )( int primitiveCode );
+	void		( *End ) ( void );
+
+	void		( *Color4f ) ( float r, float g, float b, float a );
+	void		( *Color4ub ) ( unsigned char r, unsigned char g, unsigned char b, unsigned char a );
+	void		( *TexCoord2f ) ( float u, float v );
+	void		( *Vertex3fv ) ( float *worldPnt );
+	void		( *Vertex3f ) ( float x, float y, float z );
+	void		( *Brightness ) ( float brightness );
+	void		( *CullFace ) ( TRICULLSTYLE style );
+	int			( *SpriteTexture ) ( struct model_s *pSpriteModel, int frame );
+	int			( *WorldToScreen ) ( float *world, float *screen );  // Returns 1 if it's z clipped
+	void		( *Fog ) ( float flFogColor[3], float flStart, float flEnd, int bOn ); //Works just like GL_FOG, flFogColor is r/g/b.
+	void		( *ScreenToWorld ) ( float *screen, float *world  ); 
+
+} triangleapi_t;
+
+#endif // !TRIANGLEAPIH
diff --git a/sdk/hlsdk/common/usercmd.h b/sdk/hlsdk/common/usercmd.h
new file mode 100644
index 0000000..daf78c3
--- /dev/null
+++ b/sdk/hlsdk/common/usercmd.h
@@ -0,0 +1,43 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef USERCMD_H
+#define USERCMD_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef struct usercmd_s
+{
+	short	lerp_msec;      // Interpolation time on client
+	byte	msec;           // Duration in ms of command
+	vec3_t	viewangles;     // Command view angles.
+
+// intended velocities
+	float	forwardmove;    // Forward velocity.
+	float	sidemove;       // Sideways velocity.
+	float	upmove;         // Upward velocity.
+	byte	lightlevel;     // Light level at spot where we are standing.
+	unsigned short  buttons;  // Attack buttons
+	byte    impulse;          // Impulse command issued.
+	byte	weaponselect;	// Current weapon id
+
+// Experimental player impact stuff.
+	int		impact_index;
+	vec3_t	impact_position;
+} usercmd_t;
+
+#endif // USERCMD_H
diff --git a/sdk/hlsdk/common/weaponinfo.h b/sdk/hlsdk/common/weaponinfo.h
new file mode 100644
index 0000000..4b6af25
--- /dev/null
+++ b/sdk/hlsdk/common/weaponinfo.h
@@ -0,0 +1,54 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined ( WEAPONINFOH )
+#define WEAPONINFOH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+// Info about weapons player might have in his/her possession
+typedef struct weapon_data_s
+{
+	int			m_iId;
+	int			m_iClip;
+
+	float		m_flNextPrimaryAttack;
+	float		m_flNextSecondaryAttack;
+	float		m_flTimeWeaponIdle;
+
+	int			m_fInReload;
+	int			m_fInSpecialReload;
+	float		m_flNextReload;
+	float		m_flPumpTime;
+	float		m_fReloadTime;
+
+	float		m_fAimedDamage;
+	float		m_fNextAimBonus;
+	int			m_fInZoom;
+	int			m_iWeaponState;
+
+	int			iuser1;
+	int			iuser2;
+	int			iuser3;
+	int			iuser4;
+	float		fuser1;
+	float		fuser2;
+	float		fuser3;
+	float		fuser4;
+} weapon_data_t;
+
+#endif
diff --git a/sdk/hlsdk/dlls/activity.h b/sdk/hlsdk/dlls/activity.h
new file mode 100644
index 0000000..6fd3a18
--- /dev/null
+++ b/sdk/hlsdk/dlls/activity.h
@@ -0,0 +1,109 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+
+#ifndef	ACTIVITY_H
+#define	ACTIVITY_H
+
+
+typedef enum {
+	ACT_RESET = 0,		// Set m_Activity to this invalid value to force a reset to m_IdealActivity
+	ACT_IDLE = 1,
+	ACT_GUARD,
+	ACT_WALK,
+	ACT_RUN,
+	ACT_FLY,				// Fly (and flap if appropriate)
+	ACT_SWIM,
+	ACT_HOP,				// vertical jump
+	ACT_LEAP,				// long forward jump
+	ACT_FALL,
+	ACT_LAND,
+	ACT_STRAFE_LEFT,
+	ACT_STRAFE_RIGHT,
+	ACT_ROLL_LEFT,			// tuck and roll, left
+	ACT_ROLL_RIGHT,			// tuck and roll, right
+	ACT_TURN_LEFT,			// turn quickly left (stationary)
+	ACT_TURN_RIGHT,			// turn quickly right (stationary)
+	ACT_CROUCH,				// the act of crouching down from a standing position
+	ACT_CROUCHIDLE,			// holding body in crouched position (loops)
+	ACT_STAND,				// the act of standing from a crouched position
+	ACT_USE,
+	ACT_SIGNAL1,
+	ACT_SIGNAL2,
+	ACT_SIGNAL3,
+	ACT_TWITCH,
+	ACT_COWER,
+	ACT_SMALL_FLINCH,
+	ACT_BIG_FLINCH,
+	ACT_RANGE_ATTACK1,
+	ACT_RANGE_ATTACK2,
+	ACT_MELEE_ATTACK1,
+	ACT_MELEE_ATTACK2,
+	ACT_RELOAD,
+	ACT_ARM,				// pull out gun, for instance
+	ACT_DISARM,				// reholster gun
+	ACT_EAT,				// monster chowing on a large food item (loop)
+	ACT_DIESIMPLE,
+	ACT_DIEBACKWARD,
+	ACT_DIEFORWARD,
+	ACT_DIEVIOLENT,
+	ACT_BARNACLE_HIT,		// barnacle tongue hits a monster
+	ACT_BARNACLE_PULL,		// barnacle is lifting the monster ( loop )
+	ACT_BARNACLE_CHOMP,		// barnacle latches on to the monster
+	ACT_BARNACLE_CHEW,		// barnacle is holding the monster in its mouth ( loop )
+	ACT_SLEEP,
+	ACT_INSPECT_FLOOR,		// for active idles, look at something on or near the floor
+	ACT_INSPECT_WALL,		// for active idles, look at something directly ahead of you ( doesn't HAVE to be a wall or on a wall )
+	ACT_IDLE_ANGRY,			// alternate idle animation in which the monster is clearly agitated. (loop)
+	ACT_WALK_HURT,			// limp  (loop)
+	ACT_RUN_HURT,			// limp  (loop)
+	ACT_HOVER,				// Idle while in flight
+	ACT_GLIDE,				// Fly (don't flap)
+	ACT_FLY_LEFT,			// Turn left in flight
+	ACT_FLY_RIGHT,			// Turn right in flight
+	ACT_DETECT_SCENT,		// this means the monster smells a scent carried by the air
+	ACT_SNIFF,				// this is the act of actually sniffing an item in front of the monster
+	ACT_BITE,				// some large monsters can eat small things in one bite. This plays one time, EAT loops.
+	ACT_THREAT_DISPLAY,		// without attacking, monster demonstrates that it is angry. (Yell, stick out chest, etc )
+	ACT_FEAR_DISPLAY,		// monster just saw something that it is afraid of
+	ACT_EXCITED,			// for some reason, monster is excited. Sees something he really likes to eat, or whatever.
+	ACT_SPECIAL_ATTACK1,	// very monster specific special attacks.
+	ACT_SPECIAL_ATTACK2,	
+	ACT_COMBAT_IDLE,		// agitated idle.
+	ACT_WALK_SCARED,
+	ACT_RUN_SCARED,
+	ACT_VICTORY_DANCE,		// killed a player, do a victory dance.
+	ACT_DIE_HEADSHOT,		// die, hit in head. 
+	ACT_DIE_CHESTSHOT,		// die, hit in chest
+	ACT_DIE_GUTSHOT,		// die, hit in gut
+	ACT_DIE_BACKSHOT,		// die, hit in back
+	ACT_FLINCH_HEAD,
+	ACT_FLINCH_CHEST,
+	ACT_FLINCH_STOMACH,
+	ACT_FLINCH_LEFTARM,
+	ACT_FLINCH_RIGHTARM,
+	ACT_FLINCH_LEFTLEG,
+	ACT_FLINCH_RIGHTLEG,
+} Activity;
+
+
+typedef struct {
+	int	type;
+	char *name;
+} activity_map_t;
+
+extern activity_map_t activity_map[];
+
+
+#endif	//ACTIVITY_H
diff --git a/sdk/hlsdk/dlls/activitymap.h b/sdk/hlsdk/dlls/activitymap.h
new file mode 100644
index 0000000..92cadae
--- /dev/null
+++ b/sdk/hlsdk/dlls/activitymap.h
@@ -0,0 +1,97 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+
+#define _A( a ) { a, #a }
+
+activity_map_t activity_map[] =
+{
+_A( ACT_IDLE ),
+_A(	ACT_GUARD ),
+_A(	ACT_WALK ),
+_A(	ACT_RUN ),
+_A(	ACT_FLY ),
+_A(	ACT_SWIM ),
+_A(	ACT_HOP ),
+_A(	ACT_LEAP ),
+_A(	ACT_FALL ),
+_A(	ACT_LAND ),
+_A(	ACT_STRAFE_LEFT ),
+_A(	ACT_STRAFE_RIGHT ),
+_A(	ACT_ROLL_LEFT ),
+_A(	ACT_ROLL_RIGHT ),
+_A(	ACT_TURN_LEFT ),
+_A(	ACT_TURN_RIGHT ),
+_A(	ACT_CROUCH ),
+_A(	ACT_CROUCHIDLE ),
+_A(	ACT_STAND ),
+_A(	ACT_USE ),
+_A(	ACT_SIGNAL1 ),
+_A(	ACT_SIGNAL2 ),
+_A(	ACT_SIGNAL3 ),
+_A(	ACT_TWITCH ),
+_A(	ACT_COWER ),
+_A(	ACT_SMALL_FLINCH ),
+_A(	ACT_BIG_FLINCH ),
+_A(	ACT_RANGE_ATTACK1 ),
+_A(	ACT_RANGE_ATTACK2 ),
+_A(	ACT_MELEE_ATTACK1 ),
+_A(	ACT_MELEE_ATTACK2 ),
+_A(	ACT_RELOAD ),
+_A(	ACT_ARM ),
+_A(	ACT_DISARM ),
+_A(	ACT_EAT ),
+_A(	ACT_DIESIMPLE ),
+_A(	ACT_DIEBACKWARD ),
+_A(	ACT_DIEFORWARD ),
+_A(	ACT_DIEVIOLENT ),
+_A(	ACT_BARNACLE_HIT ),
+_A(	ACT_BARNACLE_PULL ),
+_A(	ACT_BARNACLE_CHOMP ),
+_A(	ACT_BARNACLE_CHEW ),
+_A(	ACT_SLEEP ),
+_A(	ACT_INSPECT_FLOOR ),
+_A(	ACT_INSPECT_WALL ),
+_A(	ACT_IDLE_ANGRY ),
+_A(	ACT_WALK_HURT ),
+_A(	ACT_RUN_HURT ),
+_A(	ACT_HOVER ),
+_A(	ACT_GLIDE ),
+_A(	ACT_FLY_LEFT ),
+_A(	ACT_FLY_RIGHT ),
+_A(	ACT_DETECT_SCENT ),
+_A(	ACT_SNIFF ),		
+_A(	ACT_BITE ),		
+_A(	ACT_THREAT_DISPLAY ),
+_A(	ACT_FEAR_DISPLAY ),
+_A(	ACT_EXCITED ),	
+_A( ACT_SPECIAL_ATTACK1 ),
+_A( ACT_SPECIAL_ATTACK2 ),
+_A( ACT_COMBAT_IDLE		),
+_A(	ACT_WALK_SCARED ),
+_A(	ACT_RUN_SCARED ),
+_A( ACT_VICTORY_DANCE ),
+_A( ACT_DIE_HEADSHOT ),
+_A( ACT_DIE_CHESTSHOT ),
+_A( ACT_DIE_GUTSHOT ),
+_A( ACT_DIE_BACKSHOT ),
+_A(	ACT_FLINCH_HEAD ),
+_A(	ACT_FLINCH_CHEST ),
+_A(	ACT_FLINCH_STOMACH ),
+_A(	ACT_FLINCH_LEFTARM ),
+_A(	ACT_FLINCH_RIGHTARM ),
+_A(	ACT_FLINCH_LEFTLEG ),
+_A(	ACT_FLINCH_RIGHTLEG ),
+0, NULL
+};
diff --git a/sdk/hlsdk/dlls/animation.h b/sdk/hlsdk/dlls/animation.h
new file mode 100644
index 0000000..174bd71
--- /dev/null
+++ b/sdk/hlsdk/dlls/animation.h
@@ -0,0 +1,47 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef ANIMATION_H
+#define ANIMATION_H
+
+#define ACTIVITY_NOT_AVAILABLE		-1
+
+#ifndef MONSTEREVENT_H
+#include "monsterevent.h"
+#endif
+
+extern int IsSoundEvent( int eventNumber );
+
+int LookupActivity( void *pmodel, entvars_t *pev, int activity );
+int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity );
+int LookupSequence( void *pmodel, const char *label );
+void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed );
+int GetSequenceFlags( void *pmodel, entvars_t *pev );
+int LookupAnimationEvents( void *pmodel, entvars_t *pev, float flStart, float flEnd );
+float SetController( void *pmodel, entvars_t *pev, int iController, float flValue );
+float SetBlending( void *pmodel, entvars_t *pev, int iBlender, float flValue );
+void GetEyePosition( void *pmodel, float *vecEyePosition );
+void SequencePrecache( void *pmodel, const char *pSequenceName );
+int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir );
+void SetBodygroup( void *pmodel, entvars_t *pev, int iGroup, int iValue );
+int GetBodygroup( void *pmodel, entvars_t *pev, int iGroup );
+
+int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index );
+int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs );
+
+// From /engine/studio.h
+#define STUDIO_LOOPING		0x0001
+
+
+#endif	//ANIMATION_H
diff --git a/sdk/hlsdk/dlls/basemonster.h b/sdk/hlsdk/dlls/basemonster.h
new file mode 100644
index 0000000..43a2ed7
--- /dev/null
+++ b/sdk/hlsdk/dlls/basemonster.h
@@ -0,0 +1,94 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef BASEMONSTER_H
+#define BASEMONSTER_H
+
+class CBaseMonster : public CBaseToggle
+{
+public:
+	Activity			m_Activity;// what the monster is doing (animation)
+	Activity			m_IdealActivity;// monster should switch to this activity
+	int					m_LastHitGroup; // the last body region that took damage
+	int					m_bitsDamageType;	// what types of damage has monster (player) taken
+	BYTE				m_rgbTimeBasedDamage[CDMG_TIMEBASED];
+	MONSTERSTATE		m_MonsterState;// monster's current state
+	MONSTERSTATE		m_IdealMonsterState;// monster should change to this state
+	int					m_afConditions;
+	int					m_afMemory;
+	float				m_flNextAttack;		// cannot attack again until this time
+	EHANDLE				m_hEnemy;		 // the entity that the monster is fighting.
+	EHANDLE				m_hTargetEnt;	 // the entity that the monster is trying to reach
+	float				m_flFieldOfView;// width of monster's field of view ( dot product )
+	int					m_bloodColor;		// color of blood particless
+	Vector				m_HackedGunPos;	// HACK until we can query end of gun
+	Vector				m_vecEnemyLKP;// last known position of enemy. (enemy's origin)
+
+
+	void KeyValue( KeyValueData *pkvd );
+
+	void MakeIdealYaw( Vector vecTarget );
+	virtual float ChangeYaw ( int speed );
+	virtual BOOL HasHumanGibs( void );
+	virtual BOOL HasAlienGibs( void );
+	virtual void FadeMonster( void );	// Called instead of GibMonster() when gibs are disabled
+	virtual void GibMonster( void );
+	virtual Activity GetDeathActivity ( void );
+	Activity GetSmallFlinchActivity( void );
+	virtual void BecomeDead( void );
+	BOOL		 ShouldGibMonster( int iGib );
+	void		 CallGibMonster( void );
+	virtual BOOL	ShouldFadeOnDeath( void );
+	BOOL FCheckAITrigger( void );// checks and, if necessary, fires the monster's trigger target. 
+	virtual int IRelationship ( CBaseEntity *pTarget );
+	virtual int TakeHealth( float flHealth, int bitsDamageType );
+	virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType);
+	int			DeadTakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
+	float DamageForce( float damage );
+	virtual void Killed( entvars_t *pevAttacker, int iGib );
+	virtual void PainSound ( void ) { return; };
+
+	void RadiusDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
+	void RadiusDamage(Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
+
+	inline void	SetConditions( int iConditions ) { m_afConditions |= iConditions; }
+	inline void	ClearConditions( int iConditions ) { m_afConditions &= ~iConditions; }
+	inline BOOL HasConditions( int iConditions ) { if ( m_afConditions & iConditions ) return TRUE; return FALSE; }
+	inline BOOL HasAllConditions( int iConditions ) { if ( (m_afConditions & iConditions) == iConditions ) return TRUE; return FALSE; }
+
+	inline void	Remember( int iMemory ) { m_afMemory |= iMemory; }
+	inline void	Forget( int iMemory ) { m_afMemory &= ~iMemory; }
+	inline BOOL HasMemory( int iMemory ) { if ( m_afMemory & iMemory ) return TRUE; return FALSE; }
+	inline BOOL HasAllMemories( int iMemory ) { if ( (m_afMemory & iMemory) == iMemory ) return TRUE; return FALSE; }
+
+	// This will stop animation until you call ResetSequenceInfo() at some point in the future
+	inline void StopAnimation( void ) { pev->framerate = 0; }
+
+	virtual void ReportAIState( void );
+	virtual void MonsterInitDead( void );	// Call after animation/pose is set up
+	void EXPORT CorpseFallThink( void );
+
+	virtual void Look ( int iDistance );// basic sight function for monsters
+	virtual CBaseEntity* BestVisibleEnemy ( void );// finds best visible enemy for attack
+	CBaseEntity *CheckTraceHullAttack( float flDist, int iDamage, int iDmgType );
+	virtual BOOL FInViewCone ( CBaseEntity *pEntity );// see if pEntity is in monster's view cone
+	virtual BOOL FInViewCone ( Vector *pOrigin );// see if given location is in monster's view cone
+	void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
+	void MakeDamageBloodDecal ( int cCount, float flNoise, TraceResult *ptr, const Vector &vecDir );
+	virtual BOOL	IsAlive( void ) { return (pev->deadflag != DEAD_DEAD); }
+
+};
+
+
+#endif
diff --git a/sdk/hlsdk/dlls/cbase.h b/sdk/hlsdk/dlls/cbase.h
new file mode 100644
index 0000000..0474df8
--- /dev/null
+++ b/sdk/hlsdk/dlls/cbase.h
@@ -0,0 +1,797 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+/*
+
+Class Hierachy
+
+CBaseEntity
+	CBaseDelay
+		CBaseToggle
+			CBaseItem
+			CBaseMonster
+				CBaseCycler
+				CBasePlayer
+				CBaseGroup
+*/
+
+#define		MAX_PATH_SIZE	10 // max number of nodes available for a path.
+
+// These are caps bits to indicate what an object's capabilities (currently used for save/restore and level transitions)
+#define		FCAP_CUSTOMSAVE				0x00000001
+#define		FCAP_ACROSS_TRANSITION		0x00000002		// should transfer between transitions
+#define		FCAP_MUST_SPAWN				0x00000004		// Spawn after restore
+#define		FCAP_DONT_SAVE				0x80000000		// Don't save this
+#define		FCAP_IMPULSE_USE			0x00000008		// can be used by the player
+#define		FCAP_CONTINUOUS_USE			0x00000010		// can be used by the player
+#define		FCAP_ONOFF_USE				0x00000020		// can be used by the player
+#define		FCAP_DIRECTIONAL_USE		0x00000040		// Player sends +/- 1 when using (currently only tracktrains)
+#define		FCAP_MASTER					0x00000080		// Can be used to "master" other entities (like multisource)
+
+// UNDONE: This will ignore transition volumes (trigger_transition), but not the PVS!!!
+#define		FCAP_FORCE_TRANSITION		0x00000080		// ALWAYS goes across transitions
+
+#include "saverestore.h"
+#include "schedule.h"
+
+#ifndef MONSTEREVENT_H
+#include "monsterevent.h"
+#endif
+
+// C functions for external declarations that call the appropriate C++ methods
+
+#ifdef _WIN32
+#define EXPORT	_declspec( dllexport )
+#else
+#define EXPORT	/* */
+#endif
+
+extern "C" EXPORT int GetEntityAPI( DLL_FUNCTIONS *pFunctionTable, int interfaceVersion );
+extern "C" EXPORT int GetEntityAPI2( DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion );
+
+extern int DispatchSpawn( edict_t *pent );
+extern void DispatchKeyValue( edict_t *pentKeyvalue, KeyValueData *pkvd );
+extern void DispatchTouch( edict_t *pentTouched, edict_t *pentOther );
+extern void DispatchUse( edict_t *pentUsed, edict_t *pentOther );
+extern void DispatchThink( edict_t *pent );
+extern void DispatchBlocked( edict_t *pentBlocked, edict_t *pentOther );
+extern void DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData );
+extern int  DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity );
+extern void	DispatchObjectCollsionBox( edict_t *pent );
+extern void SaveWriteFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
+extern void SaveReadFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
+extern void SaveGlobalState( SAVERESTOREDATA *pSaveData );
+extern void RestoreGlobalState( SAVERESTOREDATA *pSaveData );
+extern void ResetGlobalState( void );
+
+typedef enum { USE_OFF = 0, USE_ON = 1, USE_SET = 2, USE_TOGGLE = 3 } USE_TYPE;
+
+extern void FireTargets( const char *targetName, CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+typedef void (CBaseEntity::*BASEPTR)(void);
+typedef void (CBaseEntity::*ENTITYFUNCPTR)(CBaseEntity *pOther );
+typedef void (CBaseEntity::*USEPTR)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+// For CLASSIFY
+#define	CLASS_NONE				0
+#define CLASS_MACHINE			1
+#define CLASS_PLAYER			2
+#define	CLASS_HUMAN_PASSIVE		3
+#define CLASS_HUMAN_MILITARY	4
+#define CLASS_ALIEN_MILITARY	5
+#define CLASS_ALIEN_PASSIVE		6
+#define CLASS_ALIEN_MONSTER		7
+#define CLASS_ALIEN_PREY		8
+#define CLASS_ALIEN_PREDATOR	9
+#define CLASS_INSECT			10
+#define CLASS_PLAYER_ALLY		11
+#define CLASS_PLAYER_BIOWEAPON	12 // hornets and snarks.launched by players
+#define CLASS_ALIEN_BIOWEAPON	13 // hornets and snarks.launched by the alien menace
+#define	CLASS_BARNACLE			99 // special because no one pays attention to it, and it eats a wide cross-section of creatures.
+
+class CBaseEntity;
+class CBaseMonster;
+class CBasePlayerItem;
+class CSquadMonster;
+
+
+#define	SF_NORESPAWN	( 1 << 30 )// !!!set this bit on guns and stuff that should never respawn.
+
+//
+// EHANDLE. Safe way to point to CBaseEntities who may die between frames
+//
+class EHANDLE
+{
+private:
+	edict_t *m_pent;
+	int		m_serialnumber;
+public:
+	edict_t *Get( void );
+	edict_t *Set( edict_t *pent );
+
+	operator int ();
+
+	operator CBaseEntity *();
+
+	CBaseEntity * operator = (CBaseEntity *pEntity);
+	CBaseEntity * operator ->();
+};
+
+
+//
+// Base Entity.  All entity types derive from this
+//
+class CBaseEntity 
+{
+public:
+	// Constructor.  Set engine to use C/C++ callback functions
+	// pointers to engine data
+	entvars_t *pev;		// Don't need to save/restore this pointer, the engine resets it
+
+	// path corners
+	CBaseEntity			*m_pGoalEnt;// path corner we are heading towards
+	CBaseEntity			*m_pLink;// used for temporary link-list operations. 
+
+	// initialization functions
+	virtual void	Spawn( void ) { return; }
+	virtual void	Precache( void ) { return; }
+	virtual void	KeyValue( KeyValueData* pkvd) { pkvd->fHandled = FALSE; }
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	virtual int		ObjectCaps( void ) { return FCAP_ACROSS_TRANSITION; }
+	virtual void	Activate( void ) {}
+	
+	// Setup the object->object collision box (pev->mins / pev->maxs is the object->world collision box)
+	virtual void	SetObjectCollisionBox( void );
+
+// Classify - returns the type of group (i.e, "houndeye", or "human military" so that monsters with different classnames
+// still realize that they are teammates. (overridden for monsters that form groups)
+	virtual int Classify ( void ) { return CLASS_NONE; };
+	virtual void DeathNotice ( entvars_t *pevChild ) {}// monster maker children use this to tell the monster maker that they have died.
+
+
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	virtual void	TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
+	virtual int		TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
+	virtual int		TakeHealth( float flHealth, int bitsDamageType );
+	virtual void	Killed( entvars_t *pevAttacker, int iGib );
+	virtual int		BloodColor( void ) { return DONT_BLEED; }
+	virtual void	TraceBleed( float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
+	virtual BOOL    IsTriggered( CBaseEntity *pActivator ) {return TRUE;}
+	virtual CBaseMonster *MyMonsterPointer( void ) { return NULL;}
+	virtual CSquadMonster *MySquadMonsterPointer( void ) { return NULL;}
+	virtual	int		GetToggleState( void ) { return TS_AT_TOP; }
+	virtual void	AddPoints( int score, BOOL bAllowNegativeScore ) {}
+	virtual void	AddPointsToTeam( int score, BOOL bAllowNegativeScore ) {}
+	virtual BOOL	AddPlayerItem( CBasePlayerItem *pItem ) { return 0; }
+	virtual BOOL	RemovePlayerItem( CBasePlayerItem *pItem ) { return 0; }
+	virtual int 	GiveAmmo( int iAmount, char *szName, int iMax ) { return -1; };
+	virtual float	GetDelay( void ) { return 0; }
+	virtual int		IsMoving( void ) { return pev->velocity != g_vecZero; }
+	virtual void	OverrideReset( void ) {}
+	virtual int		DamageDecal( int bitsDamageType );
+	// This is ONLY used by the node graph to test movement through a door
+	virtual void	SetToggleState( int state ) {}
+	virtual void    StartSneaking( void ) {}
+	virtual void    StopSneaking( void ) {}
+	virtual BOOL	OnControls( entvars_t *onpev ) { return FALSE; }
+	virtual BOOL    IsSneaking( void ) { return FALSE; }
+	virtual BOOL	IsAlive( void ) { return (pev->deadflag == DEAD_NO) && pev->health > 0; }
+	virtual BOOL	IsBSPModel( void ) { return pev->solid == SOLID_BSP || pev->movetype == MOVETYPE_PUSHSTEP; }
+	virtual BOOL	ReflectGauss( void ) { return ( IsBSPModel() && !pev->takedamage ); }
+	virtual BOOL	HasTarget( string_t targetname ) { return FStrEq(STRING(targetname), STRING(pev->targetname) ); }
+	virtual BOOL    IsInWorld( void );
+	virtual	BOOL	IsPlayer( void ) { return FALSE; }
+	virtual BOOL	IsNetClient( void ) { return FALSE; }
+	virtual const char *TeamID( void ) { return ""; }
+
+
+//	virtual void	SetActivator( CBaseEntity *pActivator ) {}
+	virtual CBaseEntity *GetNextTarget( void );
+	
+	// fundamental callbacks
+	void (CBaseEntity ::*m_pfnThink)(void);
+	void (CBaseEntity ::*m_pfnTouch)( CBaseEntity *pOther );
+	void (CBaseEntity ::*m_pfnUse)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	void (CBaseEntity ::*m_pfnBlocked)( CBaseEntity *pOther );
+
+	virtual void Think( void ) { if (m_pfnThink) (this->*m_pfnThink)(); };
+	virtual void Touch( CBaseEntity *pOther ) { if (m_pfnTouch) (this->*m_pfnTouch)( pOther ); };
+	virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) 
+	{ 
+		if (m_pfnUse) 
+			(this->*m_pfnUse)( pActivator, pCaller, useType, value );
+	}
+	virtual void Blocked( CBaseEntity *pOther ) { if (m_pfnBlocked) (this->*m_pfnBlocked)( pOther ); };
+
+	// allow engine to allocate instance data
+    void *operator new( size_t stAllocateBlock, entvars_t *newpev )
+	{
+		return (void *)ALLOC_PRIVATE(ENT(newpev), stAllocateBlock);
+	};
+
+	// don't use this.
+#if defined(_MSC_VER) && _MSC_VER >= 1200 // only build this code if MSVC++ 6.0 or higher
+	void operator delete(void *pMem, entvars_t *pev)
+	{
+		pev->flags |= FL_KILLME;
+	};
+#endif
+
+	void UpdateOnRemove( void );
+
+	// common member functions
+	void EXPORT SUB_Remove( void );
+	void EXPORT SUB_DoNothing( void );
+	void EXPORT SUB_StartFadeOut ( void );
+	void EXPORT SUB_FadeOut ( void );
+	void EXPORT SUB_CallUseToggle( void ) { this->Use( this, this, USE_TOGGLE, 0 ); }
+	int			ShouldToggle( USE_TYPE useType, BOOL currentState );
+	void		FireBullets( ULONG	cShots, Vector  vecSrc, Vector	vecDirShooting,	Vector	vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL  );
+	Vector		FireBulletsPlayer( ULONG	cShots, Vector  vecSrc, Vector	vecDirShooting,	Vector	vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL, int shared_rand = 0 );
+
+	virtual CBaseEntity *Respawn( void ) { return NULL; }
+
+	void SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value );
+	// Do the bounding boxes of these two intersect?
+	int		Intersects( CBaseEntity *pOther );
+	void	MakeDormant( void );
+	int		IsDormant( void );
+	BOOL    IsLockedByMaster( void ) { return FALSE; }
+
+	static CBaseEntity *Instance( edict_t *pent )
+	{ 
+		if ( !pent )
+			pent = ENT(0);
+		CBaseEntity *pEnt = (CBaseEntity *)GET_PRIVATE(pent); 
+		return pEnt; 
+	}
+
+	static CBaseEntity *Instance( entvars_t *instpev ) { return Instance( ENT( instpev ) ); }
+	static CBaseEntity *Instance( int inst_eoffset) { return Instance( ENT( inst_eoffset) ); }
+
+	CBaseMonster *GetMonsterPointer( entvars_t *pevMonster ) 
+	{ 
+		CBaseEntity *pEntity = Instance( pevMonster );
+		if ( pEntity )
+			return pEntity->MyMonsterPointer();
+		return NULL;
+	}
+	CBaseMonster *GetMonsterPointer( edict_t *pentMonster ) 
+	{ 
+		CBaseEntity *pEntity = Instance( pentMonster );
+		if ( pEntity )
+			return pEntity->MyMonsterPointer();
+		return NULL;
+	}
+
+
+	// Ugly code to lookup all functions to make sure they are exported when set.
+#ifdef _DEBUG
+	void FunctionCheck( void *pFunction, char *name ) 
+	{ 
+		if (pFunction && !NAME_FOR_FUNCTION((unsigned long)(pFunction)) )
+			ALERT( at_error, "No EXPORT: %s:%s (%08lx)\n", STRING(pev->classname), name, (unsigned long)pFunction );
+	}
+
+	BASEPTR	ThinkSet( BASEPTR func, char *name ) 
+	{ 
+		m_pfnThink = func; 
+		FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnThink)))), name ); 
+		return func;
+	}
+	ENTITYFUNCPTR TouchSet( ENTITYFUNCPTR func, char *name ) 
+	{ 
+		m_pfnTouch = func; 
+		FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnTouch)))), name ); 
+		return func;
+	}
+	USEPTR	UseSet( USEPTR func, char *name ) 
+	{ 
+		m_pfnUse = func; 
+		FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnUse)))), name ); 
+		return func;
+	}
+	ENTITYFUNCPTR	BlockedSet( ENTITYFUNCPTR func, char *name ) 
+	{ 
+		m_pfnBlocked = func; 
+		FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnBlocked)))), name ); 
+		return func;
+	}
+
+#endif
+
+
+	// virtual functions used by a few classes
+	
+	// used by monsters that are created by the MonsterMaker
+	virtual	void UpdateOwner( void ) { return; };
+
+
+	//
+	static CBaseEntity *Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner = NULL );
+
+	virtual BOOL FBecomeProne( void ) {return FALSE;};
+	edict_t *edict() { return ENT( pev ); };
+	EOFFSET eoffset( ) { return OFFSET( pev ); };
+	int	  entindex( ) { return ENTINDEX( edict() ); };
+
+	virtual Vector Center( ) { return (pev->absmax + pev->absmin) * 0.5; }; // center point of entity
+	virtual Vector EyePosition( ) { return pev->origin + pev->view_ofs; };			// position of eyes
+	virtual Vector EarPosition( ) { return pev->origin + pev->view_ofs; };			// position of ears
+	virtual Vector BodyTarget( const Vector &posSrc ) { return Center( ); };		// position to shoot at
+
+	virtual int Illumination( ) { return GETENTITYILLUM( ENT( pev ) ); };
+
+	virtual	BOOL FVisible ( CBaseEntity *pEntity );
+	virtual	BOOL FVisible ( const Vector &vecOrigin );
+
+	//We use this variables to store each ammo count.
+	int ammo_9mm;
+	int ammo_357;
+	int ammo_bolts;
+	int ammo_buckshot;
+	int ammo_rockets;
+	int ammo_uranium;
+	int ammo_hornets;
+	int ammo_argrens;
+	//Special stuff for grenades and satchels.
+	float m_flStartThrow;
+	float m_flReleaseThrow;
+	int m_chargeReady;
+	int m_fInAttack;
+
+	enum EGON_FIRESTATE { FIRE_OFF, FIRE_CHARGE };
+	int m_fireState;
+};
+
+
+
+// Ugly technique to override base member functions
+// Normally it's illegal to cast a pointer to a member function of a derived class to a pointer to a 
+// member function of a base class.  static_cast is a sleezy way around that problem.
+
+#ifdef _DEBUG
+
+#define SetThink( a ) ThinkSet( static_cast <void (CBaseEntity::*)(void)> (a), #a )
+#define SetTouch( a ) TouchSet( static_cast <void (CBaseEntity::*)(CBaseEntity *)> (a), #a )
+#define SetUse( a ) UseSet( static_cast <void (CBaseEntity::*)(	CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )> (a), #a )
+#define SetBlocked( a ) BlockedSet( static_cast <void (CBaseEntity::*)(CBaseEntity *)> (a), #a )
+
+#else
+
+#define SetThink( a ) m_pfnThink = static_cast <void (CBaseEntity::*)(void)> (a)
+#define SetTouch( a ) m_pfnTouch = static_cast <void (CBaseEntity::*)(CBaseEntity *)> (a)
+#define SetUse( a ) m_pfnUse = static_cast <void (CBaseEntity::*)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )> (a)
+#define SetBlocked( a ) m_pfnBlocked = static_cast <void (CBaseEntity::*)(CBaseEntity *)> (a)
+
+#endif
+
+
+class CPointEntity : public CBaseEntity
+{
+public:
+	void	Spawn( void );
+	virtual int	ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
+private:
+};
+
+
+typedef struct locksounds			// sounds that doors and buttons make when locked/unlocked
+{
+	string_t	sLockedSound;		// sound a door makes when it's locked
+	string_t	sLockedSentence;	// sentence group played when door is locked
+	string_t	sUnlockedSound;		// sound a door makes when it's unlocked
+	string_t	sUnlockedSentence;	// sentence group played when door is unlocked
+
+	int		iLockedSentence;		// which sentence in sentence group to play next
+	int		iUnlockedSentence;		// which sentence in sentence group to play next
+
+	float	flwaitSound;			// time delay between playing consecutive 'locked/unlocked' sounds
+	float	flwaitSentence;			// time delay between playing consecutive sentences
+	BYTE	bEOFLocked;				// true if hit end of list of locked sentences
+	BYTE	bEOFUnlocked;			// true if hit end of list of unlocked sentences
+} locksound_t;
+
+void PlayLockSounds(entvars_t *pev, locksound_t *pls, int flocked, int fbutton);
+
+//
+// MultiSouce
+//
+
+#define MAX_MULTI_TARGETS	16 // maximum number of targets a single multi_manager entity may be assigned.
+#define MS_MAX_TARGETS 32
+
+class CMultiSource : public CPointEntity
+{
+public:
+	void Spawn( );
+	void KeyValue( KeyValueData *pkvd );
+	void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	int	ObjectCaps( void ) { return (CPointEntity::ObjectCaps() | FCAP_MASTER); }
+	BOOL IsTriggered( CBaseEntity *pActivator );
+	void EXPORT Register( void );
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	EHANDLE		m_rgEntities[MS_MAX_TARGETS];
+	int			m_rgTriggered[MS_MAX_TARGETS];
+
+	int			m_iTotal;
+	string_t	m_globalstate;
+};
+
+
+//
+// generic Delay entity.
+//
+class CBaseDelay : public CBaseEntity
+{
+public:
+	float		m_flDelay;
+	int			m_iszKillTarget;
+
+	virtual void	KeyValue( KeyValueData* pkvd);
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	
+	static	TYPEDESCRIPTION m_SaveData[];
+	// common member functions
+	void SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value );
+	void EXPORT DelayThink( void );
+};
+
+
+class CBaseAnimating : public CBaseDelay
+{
+public:
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	// Basic Monster Animation functions
+	float StudioFrameAdvance( float flInterval = 0.0 ); // accumulate animation frame time from last time called until now
+	int	 GetSequenceFlags( void );
+	int  LookupActivity ( int activity );
+	int  LookupActivityHeaviest ( int activity );
+	int  LookupSequence ( const char *label );
+	void ResetSequenceInfo ( );
+	void DispatchAnimEvents ( float flFutureInterval = 0.1 ); // Handle events that have happend since last time called up until X seconds into the future
+	virtual void HandleAnimEvent( MonsterEvent_t *pEvent ) { return; };
+	float SetBoneController ( int iController, float flValue );
+	void InitBoneControllers ( void );
+	float SetBlending ( int iBlender, float flValue );
+	void GetBonePosition ( int iBone, Vector &origin, Vector &angles );
+	void GetAutomovement( Vector &origin, Vector &angles, float flInterval = 0.1 );
+	int  FindTransition( int iEndingSequence, int iGoalSequence, int *piDir );
+	void GetAttachment ( int iAttachment, Vector &origin, Vector &angles );
+	void SetBodygroup( int iGroup, int iValue );
+	int GetBodygroup( int iGroup );
+	int ExtractBbox( int sequence, float *mins, float *maxs );
+	void SetSequenceBox( void );
+
+	// animation needs
+	float				m_flFrameRate;		// computed FPS for current sequence
+	float				m_flGroundSpeed;	// computed linear movement rate for current sequence
+	float				m_flLastEventCheck;	// last time the event list was checked
+	BOOL				m_fSequenceFinished;// flag set when StudioAdvanceFrame moves across a frame boundry
+	BOOL				m_fSequenceLoops;	// true if the sequence loops
+};
+
+
+//
+// generic Toggle entity.
+//
+#define	SF_ITEM_USE_ONLY	256 //  ITEM_USE_ONLY = BUTTON_USE_ONLY = DOOR_USE_ONLY!!! 
+
+class CBaseToggle : public CBaseAnimating
+{
+public:
+	void				KeyValue( KeyValueData *pkvd );
+
+	TOGGLE_STATE		m_toggle_state;
+	float				m_flActivateFinished;//like attack_finished, but for doors
+	float				m_flMoveDistance;// how far a door should slide or rotate
+	float				m_flWait;
+	float				m_flLip;
+	float				m_flTWidth;// for plats
+	float				m_flTLength;// for plats
+
+	Vector				m_vecPosition1;
+	Vector				m_vecPosition2;
+	Vector				m_vecAngle1;
+	Vector				m_vecAngle2;
+
+	int					m_cTriggersLeft;		// trigger_counter only, # of activations remaining
+	float				m_flHeight;
+	EHANDLE				m_hActivator;
+	void (CBaseToggle::*m_pfnCallWhenMoveDone)(void);
+	Vector				m_vecFinalDest;
+	Vector				m_vecFinalAngle;
+
+	int					m_bitsDamageInflict;	// DMG_ damage type that the door or tigger does
+
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	virtual int		GetToggleState( void ) { return m_toggle_state; }
+	virtual float	GetDelay( void ) { return m_flWait; }
+
+	// common member functions
+	void LinearMove( Vector	vecDest, float flSpeed );
+	void EXPORT LinearMoveDone( void );
+	void AngularMove( Vector vecDestAngle, float flSpeed );
+	void EXPORT AngularMoveDone( void );
+	BOOL IsLockedByMaster( void );
+
+	static float		AxisValue( int flags, const Vector &angles );
+	static void			AxisDir( entvars_t *pev );
+	static float		AxisDelta( int flags, const Vector &angle1, const Vector &angle2 );
+
+	string_t m_sMaster;		// If this button has a master switch, this is the targetname.
+							// A master switch must be of the multisource type. If all 
+							// of the switches in the multisource have been triggered, then
+							// the button will be allowed to operate. Otherwise, it will be
+							// deactivated.
+};
+#define SetMoveDone( a ) m_pfnCallWhenMoveDone = static_cast <void (CBaseToggle::*)(void)> (a)
+
+
+// people gib if their health is <= this at the time of death
+#define	GIB_HEALTH_VALUE	-30
+
+#define	ROUTE_SIZE			8 // how many waypoints a monster can store at one time
+#define MAX_OLD_ENEMIES		4 // how many old enemies to remember
+
+#define	bits_CAP_DUCK			( 1 << 0 )// crouch
+#define	bits_CAP_JUMP			( 1 << 1 )// jump/leap
+#define bits_CAP_STRAFE			( 1 << 2 )// strafe ( walk/run sideways)
+#define bits_CAP_SQUAD			( 1 << 3 )// can form squads
+#define	bits_CAP_SWIM			( 1 << 4 )// proficiently navigate in water
+#define bits_CAP_CLIMB			( 1 << 5 )// climb ladders/ropes
+#define bits_CAP_USE			( 1 << 6 )// open doors/push buttons/pull levers
+#define bits_CAP_HEAR			( 1 << 7 )// can hear forced sounds
+#define bits_CAP_AUTO_DOORS		( 1 << 8 )// can trigger auto doors
+#define bits_CAP_OPEN_DOORS		( 1 << 9 )// can open manual doors
+#define bits_CAP_TURN_HEAD		( 1 << 10)// can turn head, always bone controller 0
+
+#define bits_CAP_RANGE_ATTACK1	( 1 << 11)// can do a range attack 1
+#define bits_CAP_RANGE_ATTACK2	( 1 << 12)// can do a range attack 2
+#define bits_CAP_MELEE_ATTACK1	( 1 << 13)// can do a melee attack 1
+#define bits_CAP_MELEE_ATTACK2	( 1 << 14)// can do a melee attack 2
+
+#define bits_CAP_FLY			( 1 << 15)// can fly, move all around
+
+#define bits_CAP_DOORS_GROUP    (bits_CAP_USE | bits_CAP_AUTO_DOORS | bits_CAP_OPEN_DOORS)
+
+// used by suit voice to indicate damage sustained and repaired type to player
+
+// instant damage
+
+#define DMG_GENERIC			0			// generic damage was done
+#define DMG_CRUSH			(1 << 0)	// crushed by falling or moving object
+#define DMG_BULLET			(1 << 1)	// shot
+#define DMG_SLASH			(1 << 2)	// cut, clawed, stabbed
+#define DMG_BURN			(1 << 3)	// heat burned
+#define DMG_FREEZE			(1 << 4)	// frozen
+#define DMG_FALL			(1 << 5)	// fell too far
+#define DMG_BLAST			(1 << 6)	// explosive blast damage
+#define DMG_CLUB			(1 << 7)	// crowbar, punch, headbutt
+#define DMG_SHOCK			(1 << 8)	// electric shock
+#define DMG_SONIC			(1 << 9)	// sound pulse shockwave
+#define DMG_ENERGYBEAM		(1 << 10)	// laser or other high energy beam 
+#define DMG_NEVERGIB		(1 << 12)	// with this bit OR'd in, no damage type will be able to gib victims upon death
+#define DMG_ALWAYSGIB		(1 << 13)	// with this bit OR'd in, any damage type can be made to gib victims upon death.
+#define DMG_DROWN			(1 << 14)	// Drowning
+// time-based damage
+#define DMG_TIMEBASED		(~(0x3fff))	// mask for time-based damage
+
+#define DMG_PARALYZE		(1 << 15)	// slows affected creature down
+#define DMG_NERVEGAS		(1 << 16)	// nerve toxins, very bad
+#define DMG_POISON			(1 << 17)	// blood poisioning
+#define DMG_RADIATION		(1 << 18)	// radiation exposure
+#define DMG_DROWNRECOVER	(1 << 19)	// drowning recovery
+#define DMG_ACID			(1 << 20)	// toxic chemicals or acid burns
+#define DMG_SLOWBURN		(1 << 21)	// in an oven
+#define DMG_SLOWFREEZE		(1 << 22)	// in a subzero freezer
+#define DMG_MORTAR			(1 << 23)	// Hit by air raid (done to distinguish grenade from mortar)
+
+// these are the damage types that are allowed to gib corpses
+#define DMG_GIB_CORPSE		( DMG_CRUSH | DMG_FALL | DMG_BLAST | DMG_SONIC | DMG_CLUB )
+
+// these are the damage types that have client hud art
+#define DMG_SHOWNHUD		(DMG_POISON | DMG_ACID | DMG_FREEZE | DMG_SLOWFREEZE | DMG_DROWN | DMG_BURN | DMG_SLOWBURN | DMG_NERVEGAS | DMG_RADIATION | DMG_SHOCK)
+
+// NOTE: tweak these values based on gameplay feedback:
+
+#define PARALYZE_DURATION	2		// number of 2 second intervals to take damage
+#define PARALYZE_DAMAGE		1.0		// damage to take each 2 second interval
+
+#define NERVEGAS_DURATION	2
+#define NERVEGAS_DAMAGE		5.0
+
+#define POISON_DURATION		5
+#define POISON_DAMAGE		2.0
+
+#define RADIATION_DURATION	2
+#define RADIATION_DAMAGE	1.0
+
+#define ACID_DURATION		2
+#define ACID_DAMAGE			5.0
+
+#define SLOWBURN_DURATION	2
+#define SLOWBURN_DAMAGE		1.0
+
+#define SLOWFREEZE_DURATION	2
+#define SLOWFREEZE_DAMAGE	1.0
+
+
+#define	itbd_Paralyze		0		
+#define	itbd_NerveGas		1
+#define	itbd_Poison			2
+#define	itbd_Radiation		3
+#define	itbd_DrownRecover	4
+#define	itbd_Acid			5
+#define	itbd_SlowBurn		6
+#define	itbd_SlowFreeze		7
+#define CDMG_TIMEBASED		8
+
+// when calling KILLED(), a value that governs gib behavior is expected to be 
+// one of these three values
+#define GIB_NORMAL			0// gib if entity was overkilled
+#define GIB_NEVER			1// never gib, no matter how much death damage is done ( freezing, etc )
+#define GIB_ALWAYS			2// always gib ( Houndeye Shock, Barnacle Bite )
+
+class CBaseMonster;
+class CCineMonster;
+class CSound;
+
+#include "basemonster.h"
+
+
+char *ButtonSound( int sound );				// get string of button sound number
+
+
+//
+// Generic Button
+//
+class CBaseButton : public CBaseToggle
+{
+public:
+	void Spawn( void );
+	virtual void Precache( void );
+	void RotSpawn( void );
+	virtual void KeyValue( KeyValueData* pkvd);
+
+	void ButtonActivate( );
+	void SparkSoundCache( void );
+
+	void EXPORT ButtonShot( void );
+	void EXPORT ButtonTouch( CBaseEntity *pOther );
+	void EXPORT ButtonSpark ( void );
+	void EXPORT TriggerAndWait( void );
+	void EXPORT ButtonReturn( void );
+	void EXPORT ButtonBackHome( void );
+	void EXPORT ButtonUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	virtual int		TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	
+	enum BUTTON_CODE { BUTTON_NOTHING, BUTTON_ACTIVATE, BUTTON_RETURN };
+	BUTTON_CODE	ButtonResponseToTouch( void );
+	
+	static	TYPEDESCRIPTION m_SaveData[];
+	// Buttons that don't take damage can be IMPULSE used
+	virtual int	ObjectCaps( void ) { return (CBaseToggle:: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | (pev->takedamage?0:FCAP_IMPULSE_USE); }
+
+	BOOL	m_fStayPushed;	// button stays pushed in until touched again?
+	BOOL	m_fRotating;		// a rotating button?  default is a sliding button.
+
+	string_t m_strChangeTarget;	// if this field is not null, this is an index into the engine string array.
+							// when this button is touched, it's target entity's TARGET field will be set
+							// to the button's ChangeTarget. This allows you to make a func_train switch paths, etc.
+
+	locksound_t m_ls;			// door lock sounds
+	
+	BYTE	m_bLockedSound;		// ordinals from entity selection
+	BYTE	m_bLockedSentence;	
+	BYTE	m_bUnlockedSound;	
+	BYTE	m_bUnlockedSentence;
+	int		m_sounds;
+};
+
+//
+// Weapons 
+//
+
+#define	BAD_WEAPON 0x00007FFF
+
+//
+// Converts a entvars_t * to a class pointer
+// It will allocate the class and entity if necessary
+//
+template <class T> T * GetClassPtr( T *a )
+{
+	entvars_t *pev = (entvars_t *)a;
+
+	// allocate entity if necessary
+	if (pev == NULL)
+		pev = VARS(CREATE_ENTITY());
+
+	// get the private data
+	a = (T *)GET_PRIVATE(ENT(pev));
+
+	if (a == NULL) 
+	{
+		// allocate private data 
+		a = new(pev) T;
+		a->pev = pev;
+	}
+	return a;
+}
+
+
+/*
+bit_PUSHBRUSH_DATA | bit_TOGGLE_DATA
+bit_MONSTER_DATA
+bit_DELAY_DATA
+bit_TOGGLE_DATA | bit_DELAY_DATA | bit_MONSTER_DATA
+bit_PLAYER_DATA | bit_MONSTER_DATA
+bit_MONSTER_DATA | CYCLER_DATA
+bit_LIGHT_DATA
+path_corner_data
+bit_MONSTER_DATA | wildcard_data
+bit_MONSTER_DATA | bit_GROUP_DATA
+boid_flock_data
+boid_data
+CYCLER_DATA
+bit_ITEM_DATA
+bit_ITEM_DATA | func_hud_data
+bit_TOGGLE_DATA | bit_ITEM_DATA
+EOFFSET
+env_sound_data
+env_sound_data
+push_trigger_data
+*/
+
+#define TRACER_FREQ		4			// Tracers fire every 4 bullets
+
+typedef struct _SelAmmo
+{
+	BYTE	Ammo1Type;
+	BYTE	Ammo1;
+	BYTE	Ammo2Type;
+	BYTE	Ammo2;
+} SelAmmo;
+
+
+// this moved here from world.cpp, to allow classes to be derived from it
+//=======================
+// CWorld
+//
+// This spawns first when each level begins.
+//=======================
+class CWorld : public CBaseEntity
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	void KeyValue( KeyValueData *pkvd );
+};
diff --git a/sdk/hlsdk/dlls/cdll_dll.h b/sdk/hlsdk/dlls/cdll_dll.h
new file mode 100644
index 0000000..72b79bd
--- /dev/null
+++ b/sdk/hlsdk/dlls/cdll_dll.h
@@ -0,0 +1,45 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+//
+//  cdll_dll.h
+
+// this file is included by both the game-dll and the client-dll,
+
+#ifndef CDLL_DLL_H
+#define CDLL_DLL_H
+
+#define MAX_WEAPONS		32		// ???
+
+#define MAX_WEAPON_SLOTS		5	// hud item selection slots
+#define MAX_ITEM_TYPES			6	// hud item selection slots
+
+#define MAX_ITEMS				5	// hard coded item types
+
+#define	HIDEHUD_WEAPONS		( 1<<0 )
+#define	HIDEHUD_FLASHLIGHT	( 1<<1 )
+#define	HIDEHUD_ALL			( 1<<2 )
+#define 	HIDEHUD_HEALTH		( 1<<3 )
+
+#define	MAX_AMMO_TYPES	32		// ???
+#define MAX_AMMO_SLOTS  32		// not really slots
+
+#define HUD_PRINTNOTIFY		1
+#define HUD_PRINTCONSOLE	2
+#define HUD_PRINTTALK		3
+#define HUD_PRINTCENTER		4
+
+#define WEAPON_SUIT			31
+
+#endif
diff --git a/sdk/hlsdk/dlls/client.h b/sdk/hlsdk/dlls/client.h
new file mode 100644
index 0000000..1e66cc8
--- /dev/null
+++ b/sdk/hlsdk/dlls/client.h
@@ -0,0 +1,65 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef CLIENT_H
+#define CLIENT_H
+
+extern void respawn( entvars_t* pev, BOOL fCopyCorpse );
+extern BOOL ClientConnect( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] );
+extern void ClientDisconnect( edict_t *pEntity );
+extern void ClientKill( edict_t *pEntity );
+extern void ClientPutInServer( edict_t *pEntity );
+extern void ClientCommand( edict_t *pEntity );
+extern void ClientUserInfoChanged( edict_t *pEntity, char *infobuffer );
+extern void ServerActivate( edict_t *pEdictList, int edictCount, int clientMax );
+extern void ServerDeactivate( void );
+extern void StartFrame( void );
+extern void PlayerPostThink( edict_t *pEntity );
+extern void PlayerPreThink( edict_t *pEntity );
+extern void ParmsNewLevel( void );
+extern void ParmsChangeLevel( void );
+
+extern void ClientPrecache( void );
+
+extern const char *GetGameDescription( void );
+extern void PlayerCustomization( edict_t *pEntity, customization_t *pCust );
+
+extern void SpectatorConnect ( edict_t *pEntity );
+extern void SpectatorDisconnect ( edict_t *pEntity );
+extern void SpectatorThink ( edict_t *pEntity );
+
+extern void Sys_Error( const char *error_string );
+
+extern void SetupVisibility( edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas );
+extern void	UpdateClientData ( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd );
+extern int AddToFullPack( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet );
+extern void CreateBaseline( int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs );
+extern void RegisterEncoders( void );
+
+extern int GetWeaponData( struct edict_s *player, struct weapon_data_s *info );
+
+extern void	CmdStart( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed );
+extern void	CmdEnd ( const edict_t *player );
+
+extern int	ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
+
+extern int GetHullBounds( int hullnumber, float *mins, float *maxs );
+
+extern void	CreateInstancedBaselines ( void );
+
+extern int	InconsistentFile( const edict_t *player, const char *filename, char *disconnect_message );
+
+extern int AllowLagCompensation( void );
+
+#endif		// CLIENT_H
diff --git a/sdk/hlsdk/dlls/decals.h b/sdk/hlsdk/dlls/decals.h
new file mode 100644
index 0000000..95fa44f
--- /dev/null
+++ b/sdk/hlsdk/dlls/decals.h
@@ -0,0 +1,75 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef DECALS_H
+#define DECALS_H
+
+//
+// Dynamic Decals
+//
+enum decal_e 
+{	
+	DECAL_GUNSHOT1 = 0, 
+	DECAL_GUNSHOT2,
+	DECAL_GUNSHOT3,
+	DECAL_GUNSHOT4,
+	DECAL_GUNSHOT5,
+	DECAL_LAMBDA1,
+	DECAL_LAMBDA2,
+	DECAL_LAMBDA3,
+	DECAL_LAMBDA4,
+	DECAL_LAMBDA5,
+	DECAL_LAMBDA6,
+	DECAL_SCORCH1,
+	DECAL_SCORCH2,
+	DECAL_BLOOD1, 
+	DECAL_BLOOD2, 
+	DECAL_BLOOD3, 
+	DECAL_BLOOD4, 
+	DECAL_BLOOD5, 
+	DECAL_BLOOD6, 
+	DECAL_YBLOOD1, 
+	DECAL_YBLOOD2, 
+	DECAL_YBLOOD3, 
+	DECAL_YBLOOD4, 
+	DECAL_YBLOOD5, 
+	DECAL_YBLOOD6, 
+	DECAL_GLASSBREAK1,
+	DECAL_GLASSBREAK2,
+	DECAL_GLASSBREAK3,
+	DECAL_BIGSHOT1,
+	DECAL_BIGSHOT2,
+	DECAL_BIGSHOT3,
+	DECAL_BIGSHOT4,
+	DECAL_BIGSHOT5,
+	DECAL_SPIT1,
+	DECAL_SPIT2,
+	DECAL_BPROOF1,		// Bulletproof glass decal
+	DECAL_GARGSTOMP1,	// Gargantua stomp crack
+	DECAL_SMALLSCORCH1,	// Small scorch mark
+	DECAL_SMALLSCORCH2,	// Small scorch mark
+	DECAL_SMALLSCORCH3,	// Small scorch mark
+	DECAL_MOMMABIRTH,	// Big momma birth splatter
+	DECAL_MOMMASPLAT,
+};
+
+typedef struct 
+{
+	char	*name;
+	int		index;
+} DLL_DECALLIST;
+
+extern DLL_DECALLIST gDecals[];
+
+#endif	// DECALS_H
diff --git a/sdk/hlsdk/dlls/doors.h b/sdk/hlsdk/dlls/doors.h
new file mode 100644
index 0000000..8008861
--- /dev/null
+++ b/sdk/hlsdk/dlls/doors.h
@@ -0,0 +1,33 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef DOORS_H
+#define DOORS_H
+
+// doors
+#define SF_DOOR_ROTATE_Y			0
+#define	SF_DOOR_START_OPEN			1
+#define SF_DOOR_ROTATE_BACKWARDS	2
+#define SF_DOOR_PASSABLE			8
+#define SF_DOOR_ONEWAY				16
+#define	SF_DOOR_NO_AUTO_RETURN		32
+#define SF_DOOR_ROTATE_Z			64
+#define SF_DOOR_ROTATE_X			128
+#define SF_DOOR_USE_ONLY			256	// door must be opened by player's use button.
+#define SF_DOOR_NOMONSTERS			512	// Monster can't open
+#define SF_DOOR_SILENT				0x80000000
+
+
+
+#endif		//DOORS_H
diff --git a/sdk/hlsdk/dlls/effects.h b/sdk/hlsdk/dlls/effects.h
new file mode 100644
index 0000000..1467b2f
--- /dev/null
+++ b/sdk/hlsdk/dlls/effects.h
@@ -0,0 +1,209 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef EFFECTS_H
+#define EFFECTS_H
+
+#define SF_BEAM_STARTON			0x0001
+#define SF_BEAM_TOGGLE			0x0002
+#define SF_BEAM_RANDOM			0x0004
+#define SF_BEAM_RING			0x0008
+#define SF_BEAM_SPARKSTART		0x0010
+#define SF_BEAM_SPARKEND		0x0020
+#define SF_BEAM_DECALS			0x0040
+#define SF_BEAM_SHADEIN			0x0080
+#define SF_BEAM_SHADEOUT		0x0100
+#define SF_BEAM_TEMPORARY		0x8000
+
+#define SF_SPRITE_STARTON		0x0001
+#define SF_SPRITE_ONCE			0x0002
+#define SF_SPRITE_TEMPORARY		0x8000
+
+class CSprite : public CPointEntity
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+
+	int		ObjectCaps( void )
+	{ 
+		int flags = 0;
+		if ( pev->spawnflags & SF_SPRITE_TEMPORARY )
+			flags = FCAP_DONT_SAVE;
+		return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags; 
+	}
+	void EXPORT AnimateThink( void );
+	void EXPORT ExpandThink( void );
+	void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	void Animate( float frames );
+	void Expand( float scaleSpeed, float fadeSpeed );
+	void SpriteInit( const char *pSpriteName, const Vector &origin );
+
+	inline void SetAttachment( edict_t *pEntity, int attachment )
+	{
+		if ( pEntity )
+		{
+			pev->skin = ENTINDEX(pEntity);
+			pev->body = attachment;
+			pev->aiment = pEntity;
+			pev->movetype = MOVETYPE_FOLLOW;
+		}
+	}
+	void TurnOff( void );
+	void TurnOn( void );
+	inline float Frames( void ) { return m_maxFrame; }
+	inline void SetTransparency( int rendermode, int r, int g, int b, int a, int fx )
+	{
+		pev->rendermode = rendermode;
+		pev->rendercolor.x = r;
+		pev->rendercolor.y = g;
+		pev->rendercolor.z = b;
+		pev->renderamt = a;
+		pev->renderfx = fx;
+	}
+	inline void SetTexture( int spriteIndex ) { pev->modelindex = spriteIndex; }
+	inline void SetScale( float scale ) { pev->scale = scale; }
+	inline void SetColor( int r, int g, int b ) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
+	inline void SetBrightness( int brightness ) { pev->renderamt = brightness; }
+
+	inline void AnimateAndDie( float framerate ) 
+	{ 
+		SetThink(AnimateUntilDead); 
+		pev->framerate = framerate;
+		pev->dmgtime = gpGlobals->time + (m_maxFrame / framerate); 
+		pev->nextthink = gpGlobals->time; 
+	}
+
+	void EXPORT AnimateUntilDead( void );
+
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	static	TYPEDESCRIPTION m_SaveData[];
+	static CSprite *SpriteCreate( const char *pSpriteName, const Vector &origin, BOOL animate );
+
+private:
+
+	float		m_lastTime;
+	float		m_maxFrame;
+};
+
+
+class CBeam : public CBaseEntity
+{
+public:
+	void	Spawn( void );
+	void	Precache( void );
+	int		ObjectCaps( void )
+	{ 
+		int flags = 0;
+		if ( pev->spawnflags & SF_BEAM_TEMPORARY )
+			flags = FCAP_DONT_SAVE;
+		return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags; 
+	}
+
+	void EXPORT TriggerTouch( CBaseEntity *pOther );
+
+	// These functions are here to show the way beams are encoded as entities.
+	// Encoding beams as entities simplifies their management in the client/server architecture
+	inline void	SetType( int type ) { pev->rendermode = (pev->rendermode & 0xF0) | (type&0x0F); }
+	inline void	SetFlags( int flags ) { pev->rendermode = (pev->rendermode & 0x0F) | (flags&0xF0); }
+	inline void SetStartPos( const Vector& pos ) { pev->origin = pos; }
+	inline void SetEndPos( const Vector& pos ) { pev->angles = pos; }
+	void SetStartEntity( int entityIndex );
+	void SetEndEntity( int entityIndex );
+
+	inline void SetStartAttachment( int attachment ) { pev->sequence = (pev->sequence & 0x0FFF) | ((attachment&0xF)<<12); }
+	inline void SetEndAttachment( int attachment ) { pev->skin = (pev->skin & 0x0FFF) | ((attachment&0xF)<<12); }
+
+	inline void SetTexture( int spriteIndex ) { pev->modelindex = spriteIndex; }
+	inline void SetWidth( int width ) { pev->scale = width; }
+	inline void SetNoise( int amplitude ) { pev->body = amplitude; }
+	inline void SetColor( int r, int g, int b ) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
+	inline void SetBrightness( int brightness ) { pev->renderamt = brightness; }
+	inline void SetFrame( float frame ) { pev->frame = frame; }
+	inline void SetScrollRate( int speed ) { pev->animtime = speed; }
+
+	inline int	GetType( void ) { return pev->rendermode & 0x0F; }
+	inline int	GetFlags( void ) { return pev->rendermode & 0xF0; }
+	inline int	GetStartEntity( void ) { return pev->sequence & 0xFFF; }
+	inline int	GetEndEntity( void ) { return pev->skin & 0xFFF; }
+
+	const Vector &GetStartPos( void );
+	const Vector &GetEndPos( void );
+
+	Vector Center( void ) { return (GetStartPos() + GetEndPos()) * 0.5; }; // center point of beam
+
+	inline int  GetTexture( void ) { return pev->modelindex; }
+	inline int  GetWidth( void ) { return pev->scale; }
+	inline int  GetNoise( void ) { return pev->body; }
+	// inline void GetColor( int r, int g, int b ) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
+	inline int  GetBrightness( void ) { return pev->renderamt; }
+	inline int  GetFrame( void ) { return pev->frame; }
+	inline int  GetScrollRate( void ) { return pev->animtime; }
+
+	// Call after you change start/end positions
+	void		RelinkBeam( void );
+//	void		SetObjectCollisionBox( void );
+
+	void		DoSparks( const Vector &start, const Vector &end );
+	CBaseEntity *RandomTargetname( const char *szName );
+	void		BeamDamage( TraceResult *ptr );
+	// Init after BeamCreate()
+	void		BeamInit( const char *pSpriteName, int width );
+	void		PointsInit( const Vector &start, const Vector &end );
+	void		PointEntInit( const Vector &start, int endIndex );
+	void		EntsInit( int startIndex, int endIndex );
+	void		HoseInit( const Vector &start, const Vector &direction );
+
+	static CBeam *BeamCreate( const char *pSpriteName, int width );
+
+	inline void LiveForTime( float time ) { SetThink(SUB_Remove); pev->nextthink = gpGlobals->time + time; }
+	inline void	BeamDamageInstant( TraceResult *ptr, float damage ) 
+	{ 
+		pev->dmg = damage; 
+		pev->dmgtime = gpGlobals->time - 1;
+		BeamDamage(ptr); 
+	}
+};
+
+
+#define SF_MESSAGE_ONCE			0x0001		// Fade in, not out
+#define SF_MESSAGE_ALL			0x0002		// Send to all clients
+
+
+class CLaser : public CBeam
+{
+public:
+	void	Spawn( void );
+	void	Precache( void );
+	void	KeyValue( KeyValueData *pkvd );
+
+	void	TurnOn( void );
+	void	TurnOff( void );
+	int		IsOn( void );
+
+	void	FireAtPoint( TraceResult &point );
+
+	void	EXPORT StrikeThink( void );
+	void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	CSprite	*m_pSprite;
+	int		m_iszSpriteName;
+	Vector  m_firePosition;
+};
+
+#endif		//EFFECTS_H
diff --git a/sdk/hlsdk/dlls/enginecallback.h b/sdk/hlsdk/dlls/enginecallback.h
new file mode 100644
index 0000000..953bf5a
--- /dev/null
+++ b/sdk/hlsdk/dlls/enginecallback.h
@@ -0,0 +1,162 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef ENGINECALLBACK_H
+#define ENGINECALLBACK_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#include "event_flags.h"
+
+// Must be provided by user of this code
+extern enginefuncs_t g_engfuncs;
+
+// The actual engine callbacks
+#define GETPLAYERUSERID (*g_engfuncs.pfnGetPlayerUserId)
+#define PRECACHE_MODEL	(*g_engfuncs.pfnPrecacheModel)
+#define PRECACHE_SOUND	(*g_engfuncs.pfnPrecacheSound)
+#define PRECACHE_GENERIC	(*g_engfuncs.pfnPrecacheGeneric)
+#define SET_MODEL		(*g_engfuncs.pfnSetModel)
+#define MODEL_INDEX		(*g_engfuncs.pfnModelIndex)
+#define MODEL_FRAMES	(*g_engfuncs.pfnModelFrames)
+#define SET_SIZE		(*g_engfuncs.pfnSetSize)
+#define CHANGE_LEVEL	(*g_engfuncs.pfnChangeLevel)
+#define GET_SPAWN_PARMS	(*g_engfuncs.pfnGetSpawnParms)
+#define SAVE_SPAWN_PARMS (*g_engfuncs.pfnSaveSpawnParms)
+#define VEC_TO_YAW		(*g_engfuncs.pfnVecToYaw)
+#define VEC_TO_ANGLES	(*g_engfuncs.pfnVecToAngles)
+#define MOVE_TO_ORIGIN  (*g_engfuncs.pfnMoveToOrigin)
+#define oldCHANGE_YAW		(*g_engfuncs.pfnChangeYaw)
+#define CHANGE_PITCH	(*g_engfuncs.pfnChangePitch)
+#define MAKE_VECTORS	(*g_engfuncs.pfnMakeVectors)
+#define CREATE_ENTITY	(*g_engfuncs.pfnCreateEntity)
+#define REMOVE_ENTITY	(*g_engfuncs.pfnRemoveEntity)
+#define CREATE_NAMED_ENTITY		(*g_engfuncs.pfnCreateNamedEntity)
+#define MAKE_STATIC		(*g_engfuncs.pfnMakeStatic)
+#define ENT_IS_ON_FLOOR	(*g_engfuncs.pfnEntIsOnFloor)
+#define DROP_TO_FLOOR	(*g_engfuncs.pfnDropToFloor)
+#define WALK_MOVE		(*g_engfuncs.pfnWalkMove)
+#define SET_ORIGIN		(*g_engfuncs.pfnSetOrigin)
+#define EMIT_SOUND_DYN2 (*g_engfuncs.pfnEmitSound)
+#define BUILD_SOUND_MSG (*g_engfuncs.pfnBuildSoundMsg)
+#define TRACE_LINE		(*g_engfuncs.pfnTraceLine)
+#define TRACE_TOSS		(*g_engfuncs.pfnTraceToss)
+#define TRACE_MONSTER_HULL		(*g_engfuncs.pfnTraceMonsterHull)
+#define TRACE_HULL		(*g_engfuncs.pfnTraceHull)
+#define GET_AIM_VECTOR	(*g_engfuncs.pfnGetAimVector)
+#define SERVER_COMMAND	(*g_engfuncs.pfnServerCommand)
+#define SERVER_EXECUTE	(*g_engfuncs.pfnServerExecute)
+#define CLIENT_COMMAND	(*g_engfuncs.pfnClientCommand)
+#define PARTICLE_EFFECT	(*g_engfuncs.pfnParticleEffect)
+#define LIGHT_STYLE		(*g_engfuncs.pfnLightStyle)
+#define DECAL_INDEX		(*g_engfuncs.pfnDecalIndex)
+#define POINT_CONTENTS	(*g_engfuncs.pfnPointContents)
+#define CRC32_INIT           (*g_engfuncs.pfnCRC32_Init)
+#define CRC32_PROCESS_BUFFER (*g_engfuncs.pfnCRC32_ProcessBuffer)
+#define CRC32_PROCESS_BYTE   (*g_engfuncs.pfnCRC32_ProcessByte)
+#define CRC32_FINAL          (*g_engfuncs.pfnCRC32_Final)
+#define RANDOM_LONG		(*g_engfuncs.pfnRandomLong)
+#define RANDOM_FLOAT	(*g_engfuncs.pfnRandomFloat)
+#define GETPLAYERAUTHID	(*g_engfuncs.pfnGetPlayerAuthId)
+
+inline void MESSAGE_BEGIN( int msg_dest, int msg_type, const float *pOrigin = NULL, edict_t *ed = NULL ) {
+	(*g_engfuncs.pfnMessageBegin)(msg_dest, msg_type, pOrigin, ed);
+}
+#define MESSAGE_END		(*g_engfuncs.pfnMessageEnd)
+#define WRITE_BYTE		(*g_engfuncs.pfnWriteByte)
+#define WRITE_CHAR		(*g_engfuncs.pfnWriteChar)
+#define WRITE_SHORT		(*g_engfuncs.pfnWriteShort)
+#define WRITE_LONG		(*g_engfuncs.pfnWriteLong)
+#define WRITE_ANGLE		(*g_engfuncs.pfnWriteAngle)
+#define WRITE_COORD		(*g_engfuncs.pfnWriteCoord)
+#define WRITE_STRING	(*g_engfuncs.pfnWriteString)
+#define WRITE_ENTITY	(*g_engfuncs.pfnWriteEntity)
+#define CVAR_REGISTER	(*g_engfuncs.pfnCVarRegister)
+#define CVAR_GET_FLOAT	(*g_engfuncs.pfnCVarGetFloat)
+#define CVAR_GET_STRING	(*g_engfuncs.pfnCVarGetString)
+#define CVAR_SET_FLOAT	(*g_engfuncs.pfnCVarSetFloat)
+#define CVAR_SET_STRING	(*g_engfuncs.pfnCVarSetString)
+#define CVAR_GET_POINTER (*g_engfuncs.pfnCVarGetPointer)
+#define ALERT			(*g_engfuncs.pfnAlertMessage)
+#define ENGINE_FPRINTF	(*g_engfuncs.pfnEngineFprintf)
+#define ALLOC_PRIVATE	(*g_engfuncs.pfnPvAllocEntPrivateData)
+inline void *GET_PRIVATE( edict_t *pent )
+{
+	if ( pent )
+		return pent->pvPrivateData;
+	return NULL;
+}
+
+#define FREE_PRIVATE	(*g_engfuncs.pfnFreeEntPrivateData)
+//#define STRING			(*g_engfuncs.pfnSzFromIndex)
+#define ALLOC_STRING	(*g_engfuncs.pfnAllocString)
+#define FIND_ENTITY_BY_STRING	(*g_engfuncs.pfnFindEntityByString)
+#define GETENTITYILLUM	(*g_engfuncs.pfnGetEntityIllum)
+#define FIND_ENTITY_IN_SPHERE		(*g_engfuncs.pfnFindEntityInSphere)
+#define FIND_CLIENT_IN_PVS			(*g_engfuncs.pfnFindClientInPVS)
+#define EMIT_AMBIENT_SOUND			(*g_engfuncs.pfnEmitAmbientSound)
+#define GET_MODEL_PTR				(*g_engfuncs.pfnGetModelPtr)
+#define REG_USER_MSG				(*g_engfuncs.pfnRegUserMsg)
+#define GET_BONE_POSITION			(*g_engfuncs.pfnGetBonePosition)
+#define FUNCTION_FROM_NAME			(*g_engfuncs.pfnFunctionFromName)
+#define NAME_FOR_FUNCTION			(*g_engfuncs.pfnNameForFunction)
+#define TRACE_TEXTURE				(*g_engfuncs.pfnTraceTexture)
+#define CLIENT_PRINTF				(*g_engfuncs.pfnClientPrintf)
+#define CMD_ARGS					(*g_engfuncs.pfnCmd_Args)
+#define CMD_ARGC					(*g_engfuncs.pfnCmd_Argc)
+#define CMD_ARGV					(*g_engfuncs.pfnCmd_Argv)
+#define GET_ATTACHMENT			(*g_engfuncs.pfnGetAttachment)
+#define SET_VIEW				(*g_engfuncs.pfnSetView)
+#define SET_CROSSHAIRANGLE		(*g_engfuncs.pfnCrosshairAngle)
+#define LOAD_FILE_FOR_ME		(*g_engfuncs.pfnLoadFileForMe)
+#define FREE_FILE				(*g_engfuncs.pfnFreeFile)
+#define COMPARE_FILE_TIME		(*g_engfuncs.pfnCompareFileTime)
+#define GET_GAME_DIR			(*g_engfuncs.pfnGetGameDir)
+#define IS_MAP_VALID			(*g_engfuncs.pfnIsMapValid)
+#define NUMBER_OF_ENTITIES		(*g_engfuncs.pfnNumberOfEntities)
+#define IS_DEDICATED_SERVER		(*g_engfuncs.pfnIsDedicatedServer)
+
+#define PRECACHE_EVENT			(*g_engfuncs.pfnPrecacheEvent)
+#define PLAYBACK_EVENT_FULL		(*g_engfuncs.pfnPlaybackEvent)
+
+#define ENGINE_SET_PVS			(*g_engfuncs.pfnSetFatPVS)
+#define ENGINE_SET_PAS			(*g_engfuncs.pfnSetFatPAS)
+
+#define ENGINE_CHECK_VISIBILITY (*g_engfuncs.pfnCheckVisibility)
+
+#define DELTA_SET				( *g_engfuncs.pfnDeltaSetField )
+#define DELTA_UNSET				( *g_engfuncs.pfnDeltaUnsetField )
+#define DELTA_ADDENCODER		( *g_engfuncs.pfnDeltaAddEncoder )
+#define ENGINE_CURRENT_PLAYER   ( *g_engfuncs.pfnGetCurrentPlayer )
+
+#define	ENGINE_CANSKIP			( *g_engfuncs.pfnCanSkipPlayer )
+
+#define DELTA_FINDFIELD			( *g_engfuncs.pfnDeltaFindField )
+#define DELTA_SETBYINDEX		( *g_engfuncs.pfnDeltaSetFieldByIndex )
+#define DELTA_UNSETBYINDEX		( *g_engfuncs.pfnDeltaUnsetFieldByIndex )
+
+#define ENGINE_GETPHYSINFO		( *g_engfuncs.pfnGetPhysicsInfoString )
+
+#define ENGINE_SETGROUPMASK		( *g_engfuncs.pfnSetGroupMask )
+
+#define ENGINE_INSTANCE_BASELINE ( *g_engfuncs.pfnCreateInstancedBaseline )
+
+#define ENGINE_FORCE_UNMODIFIED	( *g_engfuncs.pfnForceUnmodified )
+
+#define PLAYER_CNX_STATS		( *g_engfuncs.pfnGetPlayerStats )
+
+#endif		//ENGINECALLBACK_H
diff --git a/sdk/hlsdk/dlls/explode.h b/sdk/hlsdk/dlls/explode.h
new file mode 100644
index 0000000..3feb011
--- /dev/null
+++ b/sdk/hlsdk/dlls/explode.h
@@ -0,0 +1,32 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef EXPLODE_H
+#define EXPLODE_H
+
+
+#define	SF_ENVEXPLOSION_NODAMAGE	( 1 << 0 ) // when set, ENV_EXPLOSION will not actually inflict damage
+#define	SF_ENVEXPLOSION_REPEATABLE	( 1 << 1 ) // can this entity be refired?
+#define SF_ENVEXPLOSION_NOFIREBALL	( 1 << 2 ) // don't draw the fireball
+#define SF_ENVEXPLOSION_NOSMOKE		( 1 << 3 ) // don't draw the smoke
+#define SF_ENVEXPLOSION_NODECAL		( 1 << 4 ) // don't make a scorch mark
+#define SF_ENVEXPLOSION_NOSPARKS	( 1 << 5 ) // don't make a scorch mark
+
+extern DLL_GLOBAL	short	g_sModelIndexFireball;
+extern DLL_GLOBAL	short	g_sModelIndexSmoke;
+
+
+extern void ExplosionCreate( const Vector &center, const Vector &angles, edict_t *pOwner, int magnitude, BOOL doDamage );
+
+#endif			//EXPLODE_H
diff --git a/sdk/hlsdk/dlls/extdll.h b/sdk/hlsdk/dlls/extdll.h
new file mode 100644
index 0000000..48c7239
--- /dev/null
+++ b/sdk/hlsdk/dlls/extdll.h
@@ -0,0 +1,88 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef EXTDLL_H
+#define EXTDLL_H
+
+
+//
+// Global header file for extension DLLs
+//
+
+// Allow "DEBUG" in addition to default "_DEBUG"
+#ifdef _DEBUG
+#define DEBUG 1
+#endif
+
+#ifdef _WIN32
+// Silence certain warnings
+#pragma warning(disable : 4244)		// int or float down-conversion
+#pragma warning(disable : 4305)		// int or float data truncation
+#pragma warning(disable : 4201)		// nameless struct/union
+#pragma warning(disable : 4514)		// unreferenced inline function removed
+#pragma warning(disable : 4100)		// unreferenced formal parameter
+
+// Prevent tons of unused windows definitions
+#define WIN32_LEAN_AND_MEAN
+#define NOWINRES
+#define NOSERVICE
+#define NOMCX
+#define NOIME
+#include "windows.h"
+#else // _WIN32
+#define FALSE 0
+#define TRUE (!FALSE)
+typedef unsigned long ULONG;
+typedef unsigned char BYTE;
+typedef int BOOL;
+#define MAX_PATH PATH_MAX
+#include <limits.h>
+#include <stdarg.h>
+#ifndef min
+#define min(a,b)  (((a) < (b)) ? (a) : (b))
+#endif
+#ifndef max
+#define max(a,b)  (((a) > (b)) ? (a) : (b))
+#define _vsnprintf(a,b,c,d) vsnprintf(a,b,c,d)
+#endif
+#endif //_WIN32
+
+// Misc C-runtime library headers
+#include "stdio.h"
+#include "stdlib.h"
+#include "math.h"
+
+// Header file containing definition of globalvars_t and entvars_t
+typedef int	func_t;					//
+typedef int	string_t;				// from engine's pr_comp.h;
+typedef float vec_t;				// needed before including progdefs.h
+
+// Vector class
+#include "vector.h"
+
+// Defining it as a (bogus) struct helps enforce type-checking
+#define vec3_t Vector
+
+// Shared engine/DLL constants
+#include "const.h"
+#include "progdefs.h"
+#include "edict.h"
+
+// Shared header describing protocol between engine and DLLs
+#include "eiface.h"
+
+// Shared header between the client DLL and the game DLLs
+#include "cdll_dll.h"
+
+#endif //EXTDLL_H
diff --git a/sdk/hlsdk/dlls/func_break.h b/sdk/hlsdk/dlls/func_break.h
new file mode 100644
index 0000000..9bb281d
--- /dev/null
+++ b/sdk/hlsdk/dlls/func_break.h
@@ -0,0 +1,74 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef FUNC_BREAK_H
+#define FUNC_BREAK_H
+
+typedef enum { expRandom, expDirected} Explosions;
+typedef enum { matGlass = 0, matWood, matMetal, matFlesh, matCinderBlock, matCeilingTile, matComputer, matUnbreakableGlass, matRocks, matNone, matLastMaterial } Materials;
+
+#define	NUM_SHARDS 6 // this many shards spawned when breakable objects break;
+
+class CBreakable : public CBaseDelay
+{
+public:
+	// basic functions
+	void Spawn( void );
+	void Precache( void );
+	void KeyValue( KeyValueData* pkvd);
+	void EXPORT BreakTouch( CBaseEntity *pOther );
+	void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	void DamageSound( void );
+
+	// breakables use an overridden takedamage
+	virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
+	// To spark when hit
+	void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
+
+	BOOL IsBreakable( void );
+	BOOL SparkWhenHit( void );
+
+	int	 DamageDecal( int bitsDamageType );
+
+	void EXPORT		Die( void );
+	virtual int		ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+
+	inline BOOL		Explodable( void ) { return ExplosionMagnitude() > 0; }
+	inline int		ExplosionMagnitude( void ) { return pev->impulse; }
+	inline void		ExplosionSetMagnitude( int magnitude ) { pev->impulse = magnitude; }
+
+	static void MaterialSoundPrecache( Materials precacheMaterial );
+	static void MaterialSoundRandom( edict_t *pEdict, Materials soundMaterial, float volume );
+	static const char **MaterialSoundList( Materials precacheMaterial, int &soundCount );
+
+	static const char *pSoundsWood[];
+	static const char *pSoundsFlesh[];
+	static const char *pSoundsGlass[];
+	static const char *pSoundsMetal[];
+	static const char *pSoundsConcrete[];
+	static const char *pSpawnObjects[];
+
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	Materials	m_Material;
+	Explosions	m_Explosion;
+	int			m_idShard;
+	float		m_angle;
+	int			m_iszGibModel;
+	int			m_iszSpawnObject;
+};
+
+#endif	// FUNC_BREAK_H
diff --git a/sdk/hlsdk/dlls/game.h b/sdk/hlsdk/dlls/game.h
new file mode 100644
index 0000000..58e7e75
--- /dev/null
+++ b/sdk/hlsdk/dlls/game.h
@@ -0,0 +1,45 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+
+#ifndef GAME_H
+#define GAME_H
+
+extern void GameDLLInit( void );
+
+
+extern cvar_t	displaysoundlist;
+
+// multiplayer server rules
+extern cvar_t	teamplay;
+extern cvar_t	fraglimit;
+extern cvar_t	timelimit;
+extern cvar_t	friendlyfire;
+extern cvar_t	falldamage;
+extern cvar_t	weaponstay;
+extern cvar_t	forcerespawn;
+extern cvar_t	flashlight;
+extern cvar_t	aimcrosshair;
+extern cvar_t	decalfrequency;
+extern cvar_t	teamlist;
+extern cvar_t	teamoverride;
+extern cvar_t	defaultteam;
+extern cvar_t	allowmonsters;
+
+// Engine Cvars
+extern cvar_t	*g_psv_gravity;
+extern cvar_t	*g_psv_aim;
+extern cvar_t	*g_footsteps;
+
+#endif		// GAME_H
diff --git a/sdk/hlsdk/dlls/gamerules.h b/sdk/hlsdk/dlls/gamerules.h
new file mode 100644
index 0000000..76b3515
--- /dev/null
+++ b/sdk/hlsdk/dlls/gamerules.h
@@ -0,0 +1,360 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+//=========================================================
+// GameRules
+//=========================================================
+
+//#include "weapons.h"
+//#include "items.h"
+class CBasePlayerItem;
+class CBasePlayer;
+class CItem;
+class CBasePlayerAmmo;
+
+// weapon respawning return codes
+enum
+{	
+	GR_NONE = 0,
+	
+	GR_WEAPON_RESPAWN_YES,
+	GR_WEAPON_RESPAWN_NO,
+	
+	GR_AMMO_RESPAWN_YES,
+	GR_AMMO_RESPAWN_NO,
+	
+	GR_ITEM_RESPAWN_YES,
+	GR_ITEM_RESPAWN_NO,
+
+	GR_PLR_DROP_GUN_ALL,
+	GR_PLR_DROP_GUN_ACTIVE,
+	GR_PLR_DROP_GUN_NO,
+
+	GR_PLR_DROP_AMMO_ALL,
+	GR_PLR_DROP_AMMO_ACTIVE,
+	GR_PLR_DROP_AMMO_NO,
+};
+
+// Player relationship return codes
+enum
+{
+	GR_NOTTEAMMATE = 0,
+	GR_TEAMMATE,
+	GR_ENEMY,
+	GR_ALLY,
+	GR_NEUTRAL,
+};
+
+class CGameRules
+{
+public:
+	virtual void RefreshSkillData( void );// fill skill data struct with proper values
+	virtual void Think( void ) = 0;// GR_Think - runs every server frame, should handle any timer tasks, periodic events, etc.
+	virtual BOOL IsAllowedToSpawn( CBaseEntity *pEntity ) = 0;  // Can this item spawn (eg monsters don't spawn in deathmatch).
+
+	virtual BOOL FAllowFlashlight( void ) = 0;// Are players allowed to switch on their flashlight?
+	virtual BOOL FShouldSwitchWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon ) = 0;// should the player switch to this weapon?
+	virtual BOOL GetNextBestWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon ) = 0;// I can't use this weapon anymore, get me the next best one.
+
+// Functions to verify the single/multiplayer status of a game
+	virtual BOOL IsMultiplayer( void ) = 0;// is this a multiplayer game? (either coop or deathmatch)
+	virtual BOOL IsDeathmatch( void ) = 0;//is this a deathmatch game?
+	virtual BOOL IsTeamplay( void ) { return FALSE; };// is this deathmatch game being played with team rules?
+	virtual BOOL IsCoOp( void ) = 0;// is this a coop game?
+	virtual const char *GetGameDescription( void ) { return "Half-Life"; }  // this is the game name that gets seen in the server browser
+	
+// Client connection/disconnection
+	virtual BOOL ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] ) = 0;// a client just connected to the server (player hasn't spawned yet)
+	virtual void InitHUD( CBasePlayer *pl ) = 0;		// the client dll is ready for updating
+	virtual void ClientDisconnected( edict_t *pClient ) = 0;// a client just disconnected from the server
+	virtual void UpdateGameMode( CBasePlayer *pPlayer ) {}  // the client needs to be informed of the current game mode
+
+// Client damage rules
+	virtual float FlPlayerFallDamage( CBasePlayer *pPlayer ) = 0;// this client just hit the ground after a fall. How much damage?
+	virtual BOOL  FPlayerCanTakeDamage( CBasePlayer *pPlayer, CBaseEntity *pAttacker ) {return TRUE;};// can this player take damage from this attacker?
+	virtual BOOL ShouldAutoAim( CBasePlayer *pPlayer, edict_t *target ) { return TRUE; }
+
+// Client spawn/respawn control
+	virtual void PlayerSpawn( CBasePlayer *pPlayer ) = 0;// called by CBasePlayer::Spawn just before releasing player into the game
+	virtual void PlayerThink( CBasePlayer *pPlayer ) = 0; // called by CBasePlayer::PreThink every frame, before physics are run and after keys are accepted
+	virtual BOOL FPlayerCanRespawn( CBasePlayer *pPlayer ) = 0;// is this player allowed to respawn now?
+	virtual float FlPlayerSpawnTime( CBasePlayer *pPlayer ) = 0;// When in the future will this player be able to spawn?
+	virtual edict_t *GetPlayerSpawnSpot( CBasePlayer *pPlayer );// Place this player on their spawnspot and face them the proper direction.
+
+	virtual BOOL AllowAutoTargetCrosshair( void ) { return TRUE; };
+	virtual BOOL ClientCommand( CBasePlayer *pPlayer, const char *pcmd ) { return FALSE; };  // handles the user commands;  returns TRUE if command handled properly
+	virtual void ClientUserInfoChanged( CBasePlayer *pPlayer, char *infobuffer ) {}		// the player has changed userinfo;  can change it now
+
+// Client kills/scoring
+	virtual int IPointsForKill( CBasePlayer *pAttacker, CBasePlayer *pKilled ) = 0;// how many points do I award whoever kills this player?
+	virtual void PlayerKilled( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor ) = 0;// Called each time a player dies
+	virtual void DeathNotice( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor )=  0;// Call this from within a GameRules class to report an obituary.
+// Weapon retrieval
+	virtual BOOL CanHavePlayerItem( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon );// The player is touching an CBasePlayerItem, do I give it to him?
+	virtual void PlayerGotWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon ) = 0;// Called each time a player picks up a weapon from the ground
+
+// Weapon spawn/respawn control
+	virtual int WeaponShouldRespawn( CBasePlayerItem *pWeapon ) = 0;// should this weapon respawn?
+	virtual float FlWeaponRespawnTime( CBasePlayerItem *pWeapon ) = 0;// when may this weapon respawn?
+	virtual float FlWeaponTryRespawn( CBasePlayerItem *pWeapon ) = 0; // can i respawn now,  and if not, when should i try again?
+	virtual Vector VecWeaponRespawnSpot( CBasePlayerItem *pWeapon ) = 0;// where in the world should this weapon respawn?
+
+// Item retrieval
+	virtual BOOL CanHaveItem( CBasePlayer *pPlayer, CItem *pItem ) = 0;// is this player allowed to take this item?
+	virtual void PlayerGotItem( CBasePlayer *pPlayer, CItem *pItem ) = 0;// call each time a player picks up an item (battery, healthkit, longjump)
+
+// Item spawn/respawn control
+	virtual int ItemShouldRespawn( CItem *pItem ) = 0;// Should this item respawn?
+	virtual float FlItemRespawnTime( CItem *pItem ) = 0;// when may this item respawn?
+	virtual Vector VecItemRespawnSpot( CItem *pItem ) = 0;// where in the world should this item respawn?
+
+// Ammo retrieval
+	virtual BOOL CanHaveAmmo( CBasePlayer *pPlayer, const char *pszAmmoName, int iMaxCarry );// can this player take more of this ammo?
+	virtual void PlayerGotAmmo( CBasePlayer *pPlayer, char *szName, int iCount ) = 0;// called each time a player picks up some ammo in the world
+
+// Ammo spawn/respawn control
+	virtual int AmmoShouldRespawn( CBasePlayerAmmo *pAmmo ) = 0;// should this ammo item respawn?
+	virtual float FlAmmoRespawnTime( CBasePlayerAmmo *pAmmo ) = 0;// when should this ammo item respawn?
+	virtual Vector VecAmmoRespawnSpot( CBasePlayerAmmo *pAmmo ) = 0;// where in the world should this ammo item respawn?
+																			// by default, everything spawns
+
+// Healthcharger respawn control
+	virtual float FlHealthChargerRechargeTime( void ) = 0;// how long until a depleted HealthCharger recharges itself?
+	virtual float FlHEVChargerRechargeTime( void ) { return 0; }// how long until a depleted HealthCharger recharges itself?
+
+// What happens to a dead player's weapons
+	virtual int DeadPlayerWeapons( CBasePlayer *pPlayer ) = 0;// what do I do with a player's weapons when he's killed?
+
+// What happens to a dead player's ammo	
+	virtual int DeadPlayerAmmo( CBasePlayer *pPlayer ) = 0;// Do I drop ammo when the player dies? How much?
+
+// Teamplay stuff
+	virtual const char *GetTeamID( CBaseEntity *pEntity ) = 0;// what team is this entity on?
+	virtual int PlayerRelationship( CBaseEntity *pPlayer, CBaseEntity *pTarget ) = 0;// What is the player's relationship with this entity?
+	virtual int GetTeamIndex( const char *pTeamName ) { return -1; }
+	virtual const char *GetIndexedTeamName( int teamIndex ) { return ""; }
+	virtual BOOL IsValidTeam( const char *pTeamName ) { return TRUE; }
+	virtual void ChangePlayerTeam( CBasePlayer *pPlayer, const char *pTeamName, BOOL bKill, BOOL bGib ) {}
+	virtual const char *SetDefaultPlayerTeam( CBasePlayer *pPlayer ) { return ""; }
+
+// Sounds
+	virtual BOOL PlayTextureSounds( void ) { return TRUE; }
+	virtual BOOL PlayFootstepSounds( CBasePlayer *pl, float fvol ) { return TRUE; }
+
+// Monsters
+	virtual BOOL FAllowMonsters( void ) = 0;//are monsters allowed
+
+	// Immediately end a multiplayer game
+	virtual void EndMultiplayerGame( void ) {}
+};
+
+extern CGameRules *InstallGameRules( void );
+
+
+//=========================================================
+// CHalfLifeRules - rules for the single player Half-Life 
+// game.
+//=========================================================
+class CHalfLifeRules : public CGameRules
+{
+public:
+	CHalfLifeRules ( void );
+
+// GR_Think
+	virtual void Think( void );
+	virtual BOOL IsAllowedToSpawn( CBaseEntity *pEntity );
+	virtual BOOL FAllowFlashlight( void ) { return TRUE; };
+
+	virtual BOOL FShouldSwitchWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon );
+	virtual BOOL GetNextBestWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon );
+	
+// Functions to verify the single/multiplayer status of a game
+	virtual BOOL IsMultiplayer( void );
+	virtual BOOL IsDeathmatch( void );
+	virtual BOOL IsCoOp( void );
+
+// Client connection/disconnection
+	virtual BOOL ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] );
+	virtual void InitHUD( CBasePlayer *pl );		// the client dll is ready for updating
+	virtual void ClientDisconnected( edict_t *pClient );
+
+// Client damage rules
+	virtual float FlPlayerFallDamage( CBasePlayer *pPlayer );
+	
+// Client spawn/respawn control
+	virtual void PlayerSpawn( CBasePlayer *pPlayer );
+	virtual void PlayerThink( CBasePlayer *pPlayer );
+	virtual BOOL FPlayerCanRespawn( CBasePlayer *pPlayer );
+	virtual float FlPlayerSpawnTime( CBasePlayer *pPlayer );
+
+	virtual BOOL AllowAutoTargetCrosshair( void );
+
+// Client kills/scoring
+	virtual int IPointsForKill( CBasePlayer *pAttacker, CBasePlayer *pKilled );
+	virtual void PlayerKilled( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor );
+	virtual void DeathNotice( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor );
+
+// Weapon retrieval
+	virtual void PlayerGotWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon );
+
+// Weapon spawn/respawn control
+	virtual int WeaponShouldRespawn( CBasePlayerItem *pWeapon );
+	virtual float FlWeaponRespawnTime( CBasePlayerItem *pWeapon );
+	virtual float FlWeaponTryRespawn( CBasePlayerItem *pWeapon );
+	virtual Vector VecWeaponRespawnSpot( CBasePlayerItem *pWeapon );
+
+// Item retrieval
+	virtual BOOL CanHaveItem( CBasePlayer *pPlayer, CItem *pItem );
+	virtual void PlayerGotItem( CBasePlayer *pPlayer, CItem *pItem );
+
+// Item spawn/respawn control
+	virtual int ItemShouldRespawn( CItem *pItem );
+	virtual float FlItemRespawnTime( CItem *pItem );
+	virtual Vector VecItemRespawnSpot( CItem *pItem );
+
+// Ammo retrieval
+	virtual void PlayerGotAmmo( CBasePlayer *pPlayer, char *szName, int iCount );
+
+// Ammo spawn/respawn control
+	virtual int AmmoShouldRespawn( CBasePlayerAmmo *pAmmo );
+	virtual float FlAmmoRespawnTime( CBasePlayerAmmo *pAmmo );
+	virtual Vector VecAmmoRespawnSpot( CBasePlayerAmmo *pAmmo );
+
+// Healthcharger respawn control
+	virtual float FlHealthChargerRechargeTime( void );
+
+// What happens to a dead player's weapons
+	virtual int DeadPlayerWeapons( CBasePlayer *pPlayer );
+
+// What happens to a dead player's ammo	
+	virtual int DeadPlayerAmmo( CBasePlayer *pPlayer );
+
+// Monsters
+	virtual BOOL FAllowMonsters( void );
+
+// Teamplay stuff	
+	virtual const char *GetTeamID( CBaseEntity *pEntity ) {return "";};
+	virtual int PlayerRelationship( CBaseEntity *pPlayer, CBaseEntity *pTarget );
+};
+
+//=========================================================
+// CHalfLifeMultiplay - rules for the basic half life multiplayer
+// competition
+//=========================================================
+class CHalfLifeMultiplay : public CGameRules
+{
+public:
+	CHalfLifeMultiplay();
+
+// GR_Think
+	virtual void Think( void );
+	virtual void RefreshSkillData( void );
+	virtual BOOL IsAllowedToSpawn( CBaseEntity *pEntity );
+	virtual BOOL FAllowFlashlight( void );
+
+	virtual BOOL FShouldSwitchWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon );
+	virtual BOOL GetNextBestWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon );
+
+// Functions to verify the single/multiplayer status of a game
+	virtual BOOL IsMultiplayer( void );
+	virtual BOOL IsDeathmatch( void );
+	virtual BOOL IsCoOp( void );
+
+// Client connection/disconnection
+	// If ClientConnected returns FALSE, the connection is rejected and the user is provided the reason specified in
+	//  svRejectReason
+	// Only the client's name and remote address are provided to the dll for verification.
+	virtual BOOL ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] );
+	virtual void InitHUD( CBasePlayer *pl );		// the client dll is ready for updating
+	virtual void ClientDisconnected( edict_t *pClient );
+	virtual void UpdateGameMode( CBasePlayer *pPlayer );  // the client needs to be informed of the current game mode
+
+// Client damage rules
+	virtual float FlPlayerFallDamage( CBasePlayer *pPlayer );
+	virtual BOOL  FPlayerCanTakeDamage( CBasePlayer *pPlayer, CBaseEntity *pAttacker );
+
+// Client spawn/respawn control
+	virtual void PlayerSpawn( CBasePlayer *pPlayer );
+	virtual void PlayerThink( CBasePlayer *pPlayer );
+	virtual BOOL FPlayerCanRespawn( CBasePlayer *pPlayer );
+	virtual float FlPlayerSpawnTime( CBasePlayer *pPlayer );
+	virtual edict_t *GetPlayerSpawnSpot( CBasePlayer *pPlayer );
+
+	virtual BOOL AllowAutoTargetCrosshair( void );
+	virtual BOOL ClientCommand( CBasePlayer *pPlayer, const char *pcmd );
+
+// Client kills/scoring
+	virtual int IPointsForKill( CBasePlayer *pAttacker, CBasePlayer *pKilled );
+	virtual void PlayerKilled( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor );
+	virtual void DeathNotice( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor );
+
+// Weapon retrieval
+	virtual void PlayerGotWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon );
+	virtual BOOL CanHavePlayerItem( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon );// The player is touching an CBasePlayerItem, do I give it to him?
+
+// Weapon spawn/respawn control
+	virtual int WeaponShouldRespawn( CBasePlayerItem *pWeapon );
+	virtual float FlWeaponRespawnTime( CBasePlayerItem *pWeapon );
+	virtual float FlWeaponTryRespawn( CBasePlayerItem *pWeapon );
+	virtual Vector VecWeaponRespawnSpot( CBasePlayerItem *pWeapon );
+
+// Item retrieval
+	virtual BOOL CanHaveItem( CBasePlayer *pPlayer, CItem *pItem );
+	virtual void PlayerGotItem( CBasePlayer *pPlayer, CItem *pItem );
+
+// Item spawn/respawn control
+	virtual int ItemShouldRespawn( CItem *pItem );
+	virtual float FlItemRespawnTime( CItem *pItem );
+	virtual Vector VecItemRespawnSpot( CItem *pItem );
+
+// Ammo retrieval
+	virtual void PlayerGotAmmo( CBasePlayer *pPlayer, char *szName, int iCount );
+
+// Ammo spawn/respawn control
+	virtual int AmmoShouldRespawn( CBasePlayerAmmo *pAmmo );
+	virtual float FlAmmoRespawnTime( CBasePlayerAmmo *pAmmo );
+	virtual Vector VecAmmoRespawnSpot( CBasePlayerAmmo *pAmmo );
+
+// Healthcharger respawn control
+	virtual float FlHealthChargerRechargeTime( void );
+	virtual float FlHEVChargerRechargeTime( void );
+
+// What happens to a dead player's weapons
+	virtual int DeadPlayerWeapons( CBasePlayer *pPlayer );
+
+// What happens to a dead player's ammo	
+	virtual int DeadPlayerAmmo( CBasePlayer *pPlayer );
+
+// Teamplay stuff	
+	virtual const char *GetTeamID( CBaseEntity *pEntity ) {return "";}
+	virtual int PlayerRelationship( CBaseEntity *pPlayer, CBaseEntity *pTarget );
+
+	virtual BOOL PlayTextureSounds( void ) { return FALSE; }
+	virtual BOOL PlayFootstepSounds( CBasePlayer *pl, float fvol );
+
+// Monsters
+	virtual BOOL FAllowMonsters( void );
+
+	// Immediately end a multiplayer game
+	virtual void EndMultiplayerGame( void ) { GoToIntermission(); }
+
+protected:
+	virtual void ChangeLevel( void );
+	virtual void GoToIntermission( void );
+	float m_flIntermissionEndTime;
+	BOOL m_iEndIntermissionButtonHit;
+	void SendMOTDToClient( edict_t *client );
+};
+
+extern DLL_GLOBAL CGameRules*	g_pGameRules;
diff --git a/sdk/hlsdk/dlls/hornet.h b/sdk/hlsdk/dlls/hornet.h
new file mode 100644
index 0000000..98d1710
--- /dev/null
+++ b/sdk/hlsdk/dlls/hornet.h
@@ -0,0 +1,58 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+//=========================================================
+// Hornets
+//=========================================================
+
+//=========================================================
+// Hornet Defines
+//=========================================================
+#define HORNET_TYPE_RED			0
+#define HORNET_TYPE_ORANGE		1
+#define HORNET_RED_SPEED		(float)600
+#define HORNET_ORANGE_SPEED		(float)800
+#define	HORNET_BUZZ_VOLUME		(float)0.8
+
+extern int iHornetPuff;
+
+//=========================================================
+// Hornet - this is the projectile that the Alien Grunt fires.
+//=========================================================
+class CHornet : public CBaseMonster
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int	 Classify ( void );
+	int  IRelationship ( CBaseEntity *pTarget );
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	void IgniteTrail( void );
+	void EXPORT StartTrack ( void );
+	void EXPORT StartDart ( void );
+	void EXPORT TrackTarget ( void );
+	void EXPORT TrackTouch ( CBaseEntity *pOther );
+	void EXPORT DartTouch( CBaseEntity *pOther );
+	void EXPORT DieTouch ( CBaseEntity *pOther );
+	
+	int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
+
+	float			m_flStopAttack;
+	int				m_iHornetType;
+	float			m_flFlySpeed;
+};
+
diff --git a/sdk/hlsdk/dlls/items.h b/sdk/hlsdk/dlls/items.h
new file mode 100644
index 0000000..e985296
--- /dev/null
+++ b/sdk/hlsdk/dlls/items.h
@@ -0,0 +1,29 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef ITEMS_H
+#define ITEMS_H
+
+
+class CItem : public CBaseEntity
+{
+public:
+	void	Spawn( void );
+	CBaseEntity*	Respawn( void );
+	void	EXPORT ItemTouch( CBaseEntity *pOther );
+	void	EXPORT Materialize( void );
+	virtual BOOL MyTouch( CBasePlayer *pPlayer ) { return FALSE; };
+};
+
+#endif // ITEMS_H
diff --git a/sdk/hlsdk/dlls/maprules.h b/sdk/hlsdk/dlls/maprules.h
new file mode 100644
index 0000000..57f9939
--- /dev/null
+++ b/sdk/hlsdk/dlls/maprules.h
@@ -0,0 +1,22 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+
+#ifndef MAPRULES_H
+#define MAPRULES_H
+
+
+
+#endif		// MAPRULES_H
+
diff --git a/sdk/hlsdk/dlls/monsterevent.h b/sdk/hlsdk/dlls/monsterevent.h
new file mode 100644
index 0000000..46c5624
--- /dev/null
+++ b/sdk/hlsdk/dlls/monsterevent.h
@@ -0,0 +1,34 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef MONSTEREVENT_H
+#define MONSTEREVENT_H
+
+typedef struct
+{
+	int			event;
+	char		*options;
+} MonsterEvent_t;
+
+#define EVENT_SPECIFIC			0
+#define EVENT_SCRIPTED			1000
+#define EVENT_SHARED			2000
+#define EVENT_CLIENT			5000
+
+#define MONSTER_EVENT_BODYDROP_LIGHT	2001
+#define MONSTER_EVENT_BODYDROP_HEAVY	2002
+
+#define MONSTER_EVENT_SWISHSOUND		2010
+
+#endif		// MONSTEREVENT_H
diff --git a/sdk/hlsdk/dlls/monsters.h b/sdk/hlsdk/dlls/monsters.h
new file mode 100644
index 0000000..a0a8da6
--- /dev/null
+++ b/sdk/hlsdk/dlls/monsters.h
@@ -0,0 +1,88 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef MONSTERS_H
+#include "skill.h"
+#define MONSTERS_H
+
+/*
+
+===== monsters.h ========================================================
+
+  Header file for monster-related utility code
+
+*/
+
+// Hit Group standards
+#define	HITGROUP_GENERIC	0
+#define	HITGROUP_HEAD		1
+#define	HITGROUP_CHEST		2
+#define	HITGROUP_STOMACH	3
+#define HITGROUP_LEFTARM	4	
+#define HITGROUP_RIGHTARM	5
+#define HITGROUP_LEFTLEG	6
+#define HITGROUP_RIGHTLEG	7
+
+
+// spawn flags 256 and above are already taken by the engine
+extern void UTIL_MoveToOrigin( edict_t* pent, const Vector &vecGoal, float flDist, int iMoveType ); 
+
+Vector VecCheckToss ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flGravityAdj = 1.0 );
+Vector VecCheckThrow ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flSpeed, float flGravityAdj = 1.0 );
+extern DLL_GLOBAL Vector		g_vecAttackDir;
+extern DLL_GLOBAL CONSTANT float g_flMeleeRange;
+extern DLL_GLOBAL CONSTANT float g_flMediumRange;
+extern DLL_GLOBAL CONSTANT float g_flLongRange;
+extern void EjectBrass (const Vector &vecOrigin, const Vector &vecVelocity, float rotation, int model, int soundtype );
+extern void ExplodeModel( const Vector &vecOrigin, float speed, int model, int count );
+
+BOOL FBoxVisible ( entvars_t *pevLooker, entvars_t *pevTarget );
+BOOL FBoxVisible ( entvars_t *pevLooker, entvars_t *pevTarget, Vector &vecTargetOrigin, float flSize = 0.0 );
+
+// monster to monster relationship types
+#define R_AL	-2 // (ALLY) pals. Good alternative to R_NO when applicable.
+#define R_FR	-1// (FEAR)will run
+#define	R_NO	0// (NO RELATIONSHIP) disregard
+#define R_DL	1// (DISLIKE) will attack
+#define R_HT	2// (HATE)will attack this character instead of any visible DISLIKEd characters
+#define R_NM	3// (NEMESIS)  A monster Will ALWAYS attack its nemsis, no matter what
+
+
+#define bits_MEMORY_KILLED				( 1 << 7 )// HACKHACK -- remember that I've already called my Killed()
+
+//
+// A gib is a chunk of a body, or a piece of wood/metal/rocks/etc.
+//
+class CGib : public CBaseEntity
+{
+public:
+	void Spawn( const char *szGibModel );
+	void EXPORT BounceGibTouch ( CBaseEntity *pOther );
+	void EXPORT StickyGibTouch ( CBaseEntity *pOther );
+	void EXPORT WaitTillLand( void );
+	void		LimitVelocity( void );
+
+	virtual int	ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_DONT_SAVE; }
+	static	void SpawnHeadGib( entvars_t *pevVictim );
+	static	void SpawnRandomGibs( entvars_t *pevVictim, int cGibs, int human );
+	static  void SpawnStickyGibs( entvars_t *pevVictim, Vector vecOrigin, int cGibs );
+
+	int		m_bloodColor;
+	int		m_cBloodDecals;
+	int		m_material;
+	float	m_lifeTime;
+};
+
+
+#endif	//MONSTERS_H
diff --git a/sdk/hlsdk/dlls/nodes.h b/sdk/hlsdk/dlls/nodes.h
new file mode 100644
index 0000000..b1a5d13
--- /dev/null
+++ b/sdk/hlsdk/dlls/nodes.h
@@ -0,0 +1,54 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+//=========================================================
+// nodes.h
+//=========================================================
+
+#ifndef	NODES_H
+#define	NODES_H
+
+#define	bits_NODE_GROUP_REALM	1
+
+class CLink
+{
+public:
+	entvars_t	*m_pLinkEnt;// the entity that blocks this connection (doors, etc)
+};
+
+
+class CGraph
+{
+public:
+	BOOL	m_fGraphPresent;// is the graph in memory?
+	BOOL	m_fGraphPointersSet;// are the entity pointers for the graph all set?
+
+	int		m_cLinks;// total number of links
+	CLink	*m_pLinkPool;// big list of all node connections
+
+	void	InitGraph( void );
+	int		AllocNodes ( void );
+	
+	int		CheckNODFile(char *szMapName);
+	int		FLoadGraph(char *szMapName);
+	int		FSetGraphPointers(void);
+	void	ShowNodeConnections ( int iNode );
+	int		FindNearestNode ( const Vector &vecOrigin, CBaseEntity *pEntity );
+	int		FindNearestNode ( const Vector &vecOrigin, int afNodeTypes );
+
+};
+
+extern CGraph WorldGraph;
+
+#endif	// NODES_H
\ No newline at end of file
diff --git a/sdk/hlsdk/dlls/plane.h b/sdk/hlsdk/dlls/plane.h
new file mode 100644
index 0000000..af70f1c
--- /dev/null
+++ b/sdk/hlsdk/dlls/plane.h
@@ -0,0 +1,43 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef PLANE_H
+#define PLANE_H
+
+//=========================================================
+// Plane
+//=========================================================
+class CPlane 
+{
+public:
+	CPlane ( void );
+
+	//=========================================================
+	// InitializePlane - Takes a normal for the plane and a
+	// point on the plane and 
+	//=========================================================
+	void InitializePlane ( const Vector &vecNormal, const Vector &vecPoint );
+
+	//=========================================================
+	// PointInFront - determines whether the given vector is 
+	// in front of the plane. 
+	//=========================================================
+	BOOL PointInFront ( const Vector &vecPoint );
+
+	Vector	m_vecNormal;
+	float	m_flDist;
+	BOOL	m_fInitialized;
+};
+
+#endif // PLANE_H
diff --git a/sdk/hlsdk/dlls/player.h b/sdk/hlsdk/dlls/player.h
new file mode 100644
index 0000000..439058f
--- /dev/null
+++ b/sdk/hlsdk/dlls/player.h
@@ -0,0 +1,324 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef PLAYER_H
+#define PLAYER_H
+
+
+#include "pm_materials.h"
+
+
+#define PLAYER_FATAL_FALL_SPEED		1024// approx 60 feet
+#define PLAYER_MAX_SAFE_FALL_SPEED	580// approx 20 feet
+#define DAMAGE_FOR_FALL_SPEED		(float) 100 / ( PLAYER_FATAL_FALL_SPEED - PLAYER_MAX_SAFE_FALL_SPEED )// damage per unit per second.
+#define PLAYER_MIN_BOUNCE_SPEED		200
+#define PLAYER_FALL_PUNCH_THRESHHOLD (float)350 // won't punch player's screen/make scrape noise unless player falling at least this fast.
+
+//
+// Player PHYSICS FLAGS bits
+//
+#define		PFLAG_ONLADDER		( 1<<0 )
+#define		PFLAG_ONSWING		( 1<<0 )
+#define		PFLAG_ONTRAIN		( 1<<1 )
+#define		PFLAG_ONBARNACLE	( 1<<2 )
+#define		PFLAG_DUCKING		( 1<<3 )		// In the process of ducking, but totally squatted yet
+#define		PFLAG_USING			( 1<<4 )		// Using a continuous entity
+#define		PFLAG_OBSERVER		( 1<<5 )		// player is locked in stationary cam mode. Spectators can move, observers can't.
+
+//
+// generic player
+//
+//-----------------------------------------------------
+//This is Half-Life player entity
+//-----------------------------------------------------
+#define CSUITPLAYLIST	4		// max of 4 suit sentences queued up at any time
+
+#define SUIT_GROUP			TRUE
+#define	SUIT_SENTENCE		FALSE
+
+#define	SUIT_REPEAT_OK		0
+#define SUIT_NEXT_IN_30SEC	30
+#define SUIT_NEXT_IN_1MIN	60
+#define SUIT_NEXT_IN_5MIN	300
+#define SUIT_NEXT_IN_10MIN	600
+#define SUIT_NEXT_IN_30MIN	1800
+#define SUIT_NEXT_IN_1HOUR	3600
+
+#define CSUITNOREPEAT		32
+
+#define	SOUND_FLASHLIGHT_ON		"items/flashlight1.wav"
+#define	SOUND_FLASHLIGHT_OFF	"items/flashlight1.wav"
+
+#define TEAM_NAME_LENGTH	16
+
+typedef enum
+{
+	PLAYER_IDLE,
+	PLAYER_WALK,
+	PLAYER_JUMP,
+	PLAYER_SUPERJUMP,
+	PLAYER_DIE,
+	PLAYER_ATTACK1,
+} PLAYER_ANIM;
+
+#define MAX_ID_RANGE 2048
+#define SBAR_STRING_SIZE 128
+
+enum sbar_data
+{
+	SBAR_ID_TARGETNAME = 1,
+	SBAR_ID_TARGETHEALTH,
+	SBAR_ID_TARGETARMOR,
+	SBAR_END,
+};
+
+#define CHAT_INTERVAL 1.0f
+
+class CBasePlayer : public CBaseMonster
+{
+public:
+	int					random_seed;    // See that is shared between client & server for shared weapons code
+
+	int					m_iPlayerSound;// the index of the sound list slot reserved for this player
+	int					m_iTargetVolume;// ideal sound volume. 
+	int					m_iWeaponVolume;// how loud the player's weapon is right now.
+	int					m_iExtraSoundTypes;// additional classification for this weapon's sound
+	int					m_iWeaponFlash;// brightness of the weapon flash
+	float				m_flStopExtraSoundTime;
+	
+	float				m_flFlashLightTime;	// Time until next battery draw/Recharge
+	int					m_iFlashBattery;		// Flashlight Battery Draw
+
+	int					m_afButtonLast;
+	int					m_afButtonPressed;
+	int					m_afButtonReleased;
+	
+	edict_t			   *m_pentSndLast;			// last sound entity to modify player room type
+	float				m_flSndRoomtype;		// last roomtype set by sound entity
+	float				m_flSndRange;			// dist from player to sound entity
+
+	float				m_flFallVelocity;
+	
+	int					m_rgItems[MAX_ITEMS];
+	int					m_fKnownItem;		// True when a new item needs to be added
+	int					m_fNewAmmo;			// True when a new item has been added
+
+	unsigned int		m_afPhysicsFlags;	// physics flags - set when 'normal' physics should be revisited or overriden
+	float				m_fNextSuicideTime; // the time after which the player can next use the suicide command
+
+
+// these are time-sensitive things that we keep track of
+	float				m_flTimeStepSound;	// when the last stepping sound was made
+	float				m_flTimeWeaponIdle; // when to play another weapon idle animation.
+	float				m_flSwimTime;		// how long player has been underwater
+	float				m_flDuckTime;		// how long we've been ducking
+	float				m_flWallJumpTime;	// how long until next walljump
+
+	float				m_flSuitUpdate;					// when to play next suit update
+	int					m_rgSuitPlayList[CSUITPLAYLIST];// next sentencenum to play for suit update
+	int					m_iSuitPlayNext;				// next sentence slot for queue storage;
+	int					m_rgiSuitNoRepeat[CSUITNOREPEAT];		// suit sentence no repeat list
+	float				m_rgflSuitNoRepeatTime[CSUITNOREPEAT];	// how long to wait before allowing repeat
+	int					m_lastDamageAmount;		// Last damage taken
+	float				m_tbdPrev;				// Time-based damage timer
+
+	float				m_flgeigerRange;		// range to nearest radiation source
+	float				m_flgeigerDelay;		// delay per update of range msg to client
+	int					m_igeigerRangePrev;
+	int					m_iStepLeft;			// alternate left/right foot stepping sound
+	char				m_szTextureName[CBTEXTURENAMEMAX];	// current texture name we're standing on
+	char				m_chTextureType;		// current texture type
+
+	int					m_idrowndmg;			// track drowning damage taken
+	int					m_idrownrestored;		// track drowning damage restored
+
+	int					m_bitsHUDDamage;		// Damage bits for the current fame. These get sent to 
+												// the hude via the DAMAGE message
+	BOOL				m_fInitHUD;				// True when deferred HUD restart msg needs to be sent
+	BOOL				m_fGameHUDInitialized;
+	int					m_iTrain;				// Train control position
+	BOOL				m_fWeapon;				// Set this to FALSE to force a reset of the current weapon HUD info
+
+	EHANDLE				m_pTank;				// the tank which the player is currently controlling,  NULL if no tank
+	float				m_fDeadTime;			// the time at which the player died  (used in PlayerDeathThink())
+
+	BOOL			m_fNoPlayerSound;	// a debugging feature. Player makes no sound if this is true. 
+	BOOL			m_fLongJump; // does this player have the longjump module?
+
+	float       m_tSneaking;
+	int			m_iUpdateTime;		// stores the number of frame ticks before sending HUD update messages
+	int			m_iClientHealth;	// the health currently known by the client.  If this changes, send a new
+	int			m_iClientBattery;	// the Battery currently known by the client.  If this changes, send a new
+	int			m_iHideHUD;		// the players hud weapon info is to be hidden
+	int			m_iClientHideHUD;
+	int			m_iFOV;			// field of view
+	int			m_iClientFOV;	// client's known FOV
+	// usable player items 
+	CBasePlayerItem	*m_rgpPlayerItems[MAX_ITEM_TYPES];
+	CBasePlayerItem *m_pActiveItem;
+	CBasePlayerItem *m_pClientActiveItem;  // client version of the active item
+	CBasePlayerItem *m_pLastItem;
+	// shared ammo slots
+	int	m_rgAmmo[MAX_AMMO_SLOTS];
+	int	m_rgAmmoLast[MAX_AMMO_SLOTS];
+
+	Vector				m_vecAutoAim;
+	BOOL				m_fOnTarget;
+	int					m_iDeaths;
+	float				m_iRespawnFrames;	// used in PlayerDeathThink() to make sure players can always respawn
+
+	int m_lastx, m_lasty;  // These are the previous update's crosshair angles, DON"T SAVE/RESTORE
+
+	int m_nCustomSprayFrames;// Custom clan logo frames for this player
+	float	m_flNextDecalTime;// next time this player can spray a decal
+
+	char m_szTeamName[TEAM_NAME_LENGTH];
+
+	virtual void Spawn( void );
+	void Pain( void );
+
+//	virtual void Think( void );
+	virtual void Jump( void );
+	virtual void Duck( void );
+	virtual void PreThink( void );
+	virtual void PostThink( void );
+	virtual Vector GetGunPosition( void );
+	virtual int TakeHealth( float flHealth, int bitsDamageType );
+	virtual void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
+	virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType);
+	virtual void	Killed( entvars_t *pevAttacker, int iGib );
+	virtual Vector BodyTarget( const Vector &posSrc ) { return Center( ) + pev->view_ofs * RANDOM_FLOAT( 0.5, 1.1 ); };		// position to shoot at
+	virtual void StartSneaking( void ) { m_tSneaking = gpGlobals->time - 1; }
+	virtual void StopSneaking( void ) { m_tSneaking = gpGlobals->time + 30; }
+	virtual BOOL IsSneaking( void ) { return m_tSneaking <= gpGlobals->time; }
+	virtual BOOL IsAlive( void ) { return (pev->deadflag == DEAD_NO) && pev->health > 0; }
+	virtual BOOL ShouldFadeOnDeath( void ) { return FALSE; }
+	virtual	BOOL IsPlayer( void ) { return TRUE; }			// Spectators should return FALSE for this, they aren't "players" as far as game logic is concerned
+
+	virtual BOOL IsNetClient( void ) { return TRUE; }		// Bots should return FALSE for this, they can't receive NET messages
+															// Spectators should return TRUE for this
+	virtual const char *TeamID( void );
+
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	void RenewItems(void);
+	void PackDeadPlayerItems( void );
+	void RemoveAllItems( BOOL removeSuit );
+	BOOL SwitchWeapon( CBasePlayerItem *pWeapon );
+
+	// JOHN:  sends custom messages if player HUD data has changed  (eg health, ammo)
+	virtual void UpdateClientData( void );
+	
+	static	TYPEDESCRIPTION m_playerSaveData[];
+
+	// Player is moved across the transition by other means
+	virtual int		ObjectCaps( void ) { return CBaseMonster :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
+	virtual void	Precache( void );
+	BOOL			IsOnLadder( void );
+	BOOL			FlashlightIsOn( void );
+	void			FlashlightTurnOn( void );
+	void			FlashlightTurnOff( void );
+	
+	void UpdatePlayerSound ( void );
+	void DeathSound ( void );
+
+	int Classify ( void );
+	void SetAnimation( PLAYER_ANIM playerAnim );
+	void SetWeaponAnimType( const char *szExtention );
+	char m_szAnimExtention[32];
+
+	// custom player functions
+	virtual void ImpulseCommands( void );
+	void CheatImpulseCommands( int iImpulse );
+
+	void StartDeathCam( void );
+	void StartObserver( Vector vecPosition, Vector vecViewAngle );
+
+	void AddPoints( int score, BOOL bAllowNegativeScore );
+	void AddPointsToTeam( int score, BOOL bAllowNegativeScore );
+	BOOL AddPlayerItem( CBasePlayerItem *pItem );
+	BOOL RemovePlayerItem( CBasePlayerItem *pItem );
+	void DropPlayerItem ( char *pszItemName );
+	BOOL HasPlayerItem( CBasePlayerItem *pCheckItem );
+	BOOL HasNamedPlayerItem( const char *pszItemName );
+	BOOL HasWeapons( void );// do I have ANY weapons?
+	void SelectPrevItem( int iItem );
+	void SelectNextItem( int iItem );
+	void SelectLastItem(void);
+	void SelectItem(const char *pstr);
+	void ItemPreFrame( void );
+	void ItemPostFrame( void );
+	void GiveNamedItem( const char *szName );
+	void EnableControl(BOOL fControl);
+
+	int  GiveAmmo( int iAmount, char *szName, int iMax );
+	void SendAmmoUpdate(void);
+
+	void WaterMove( void );
+	void EXPORT PlayerDeathThink( void );
+	void PlayerUse( void );
+
+	void CheckSuitUpdate();
+	void SetSuitUpdate(char *name, int fgroup, int iNoRepeat);
+	void UpdateGeigerCounter( void );
+	void CheckTimeBasedDamage( void );
+
+	BOOL FBecomeProne ( void );
+	void BarnacleVictimBitten ( entvars_t *pevBarnacle );
+	void BarnacleVictimReleased ( void );
+	static int GetAmmoIndex(const char *psz);
+	int AmmoInventory( int iAmmoIndex );
+	int Illumination( void );
+
+	void ResetAutoaim( void );
+	Vector GetAutoaimVector( float flDelta  );
+	Vector AutoaimDeflection( Vector &vecSrc, float flDist, float flDelta  );
+
+	void ForceClientDllUpdate( void );  // Forces all client .dll specific data to be resent to client.
+
+	void DeathMessage( entvars_t *pevKiller );
+
+	void SetCustomDecalFrames( int nFrames );
+	int GetCustomDecalFrames( void );
+
+	void CBasePlayer::TabulateAmmo( void );
+
+	float m_flStartCharge;
+	float m_flAmmoStartCharge;
+	float m_flPlayAftershock;
+	float m_flNextAmmoBurn;// while charging, when to absorb another unit of player's ammo?
+	
+	//Player ID
+	void InitStatusBar( void );
+	void UpdateStatusBar( void );
+	int m_izSBarState[ SBAR_END ];
+	float m_flNextSBarUpdateTime;
+	float m_flStatusBarDisappearDelay;
+	char m_SbarString0[ SBAR_STRING_SIZE ];
+	char m_SbarString1[ SBAR_STRING_SIZE ];
+	
+	float m_flNextChatTime;
+	
+};
+
+#define AUTOAIM_2DEGREES  0.0348994967025
+#define AUTOAIM_5DEGREES  0.08715574274766
+#define AUTOAIM_8DEGREES  0.1391731009601
+#define AUTOAIM_10DEGREES 0.1736481776669
+
+
+extern int	gmsgHudText;
+extern BOOL gInitHUD;
+
+#endif // PLAYER_H
diff --git a/sdk/hlsdk/dlls/saverestore.h b/sdk/hlsdk/dlls/saverestore.h
new file mode 100644
index 0000000..f1cd418
--- /dev/null
+++ b/sdk/hlsdk/dlls/saverestore.h
@@ -0,0 +1,176 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+// Implementation in UTIL.CPP
+#ifndef SAVERESTORE_H
+#define SAVERESTORE_H
+
+class CBaseEntity;
+
+class CSaveRestoreBuffer
+{
+public:
+	CSaveRestoreBuffer( void );
+	CSaveRestoreBuffer( SAVERESTOREDATA *pdata );
+	virtual ~CSaveRestoreBuffer( void );
+
+	int			EntityIndex( entvars_t *pevLookup );
+	int			EntityIndex( edict_t *pentLookup );
+	int			EntityIndex( EOFFSET eoLookup );
+	int			EntityIndex( CBaseEntity *pEntity );
+
+	int			EntityFlags( int entityIndex, int flags ) { return EntityFlagsSet( entityIndex, 0 ); }
+	int			EntityFlagsSet( int entityIndex, int flags );
+
+	edict_t		*EntityFromIndex( int entityIndex );
+
+	unsigned short	TokenHash( const char *pszToken );
+
+protected:
+	SAVERESTOREDATA		*m_pdata;
+	void		BufferRewind( int size );
+	unsigned int	HashString( const char *pszToken );
+private:
+	// effc++ rule 11
+	void		operator=(CSaveRestoreBuffer&);
+	CSaveRestoreBuffer(const CSaveRestoreBuffer&);
+};
+
+
+class CSave : public CSaveRestoreBuffer
+{
+public:
+	CSave( SAVERESTOREDATA *pdata ) : CSaveRestoreBuffer( pdata ) {};
+
+	void	WriteShort( const char *pname, const short *value, int count );
+	void	WriteInt( const char *pname, const int *value, int count );		// Save an int
+	void	WriteFloat( const char *pname, const float *value, int count );	// Save a float
+	void	WriteTime( const char *pname, const float *value, int count );	// Save a float (timevalue)
+	void	WriteData( const char *pname, int size, const char *pdata );		// Save a binary data block
+	void	WriteString( const char *pname, const char *pstring );			// Save a null-terminated string
+	void	WriteString( const char *pname, const int *stringId, int count );	// Save a null-terminated string (engine string)
+	void	WriteVector( const char *pname, const Vector &value );				// Save a vector
+	void	WriteVector( const char *pname, const float *value, int count );	// Save a vector
+	void	WritePositionVector( const char *pname, const Vector &value );		// Offset for landmark if necessary
+	void	WritePositionVector( const char *pname, const float *value, int count );	// array of pos vectors
+	void	WriteFunction( const char *pname, const int *value, int count );		// Save a function pointer
+	int		WriteEntVars( const char *pname, entvars_t *pev );		// Save entvars_t (entvars_t)
+	int		WriteFields( const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
+
+private:
+	int		DataEmpty( const char *pdata, int size );
+	void	BufferField( const char *pname, int size, const char *pdata );
+	void	BufferString( char *pdata, int len );
+	void	BufferData( const char *pdata, int size );
+	void	BufferHeader( const char *pname, int size );
+};
+
+typedef struct 
+{
+	unsigned short		size;
+	unsigned short		token;
+	char				*pData;
+} HEADER;
+
+class CRestore : public CSaveRestoreBuffer
+{
+public:
+	CRestore( SAVERESTOREDATA *pdata ) : CSaveRestoreBuffer( pdata ), m_global(0), m_precache(TRUE) { }
+	int		ReadEntVars( const char *pname, entvars_t *pev );		// entvars_t
+	int		ReadFields( const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
+	int		ReadField( void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount, int startField, int size, char *pName, void *pData );
+	int		ReadInt( void );
+	short	ReadShort( void );
+	int		ReadNamedInt( const char *pName );
+	char	*ReadNamedString( const char *pName );
+	int		Empty( void ) { return (m_pdata == NULL) || ((m_pdata->pCurrentData-m_pdata->pBaseData)>=m_pdata->bufferSize); }
+	inline	void SetGlobalMode( int global ) { m_global = global; }
+	void	PrecacheMode( BOOL mode ) { m_precache = mode; }
+
+private:
+	char	*BufferPointer( void );
+	void	BufferReadBytes( char *pOutput, int size );
+	void	BufferSkipBytes( int bytes );
+	int		BufferSkipZString( void );
+	int		BufferCheckZString( const char *string );
+
+	void	BufferReadHeader( HEADER *pheader );
+
+	int		m_global;		// Restoring a global entity?
+	BOOL	m_precache;
+};
+
+#define MAX_ENTITYARRAY 64
+
+//#define ARRAYSIZE(p)		(sizeof(p)/sizeof(p[0]))
+
+#define IMPLEMENT_SAVERESTORE(derivedClass,baseClass) \
+	int derivedClass::Save( CSave &save )\
+	{\
+		if ( !baseClass::Save(save) )\
+			return 0;\
+		return save.WriteFields( #derivedClass, this, m_SaveData, ARRAYSIZE(m_SaveData) );\
+	}\
+	int derivedClass::Restore( CRestore &restore )\
+	{\
+		if ( !baseClass::Restore(restore) )\
+			return 0;\
+		return restore.ReadFields( #derivedClass, this, m_SaveData, ARRAYSIZE(m_SaveData) );\
+	}
+
+
+typedef enum { GLOBAL_OFF = 0, GLOBAL_ON = 1, GLOBAL_DEAD = 2 } GLOBALESTATE;
+
+typedef struct globalentity_s globalentity_t;
+
+struct globalentity_s
+{
+	char			name[64];
+	char			levelName[32];
+	GLOBALESTATE	state;
+	globalentity_t	*pNext;
+};
+
+class CGlobalState
+{
+public:
+					CGlobalState();
+	void			Reset( void );
+	void			ClearStates( void );
+	void			EntityAdd( string_t globalname, string_t mapName, GLOBALESTATE state );
+	void			EntitySetState( string_t globalname, GLOBALESTATE state );
+	void			EntityUpdate( string_t globalname, string_t mapname );
+	const globalentity_t	*EntityFromTable( string_t globalname );
+	GLOBALESTATE	EntityGetState( string_t globalname );
+	int				EntityInTable( string_t globalname ) { return (Find( globalname ) != NULL) ? 1 : 0; }
+	int				Save( CSave &save );
+	int				Restore( CRestore &restore );
+	static TYPEDESCRIPTION m_SaveData[];
+
+//#ifdef _DEBUG
+	void			DumpGlobals( void );
+//#endif
+
+private:
+	globalentity_t	*Find( string_t globalname );
+	globalentity_t	*m_pList;
+	int				m_listCount;
+	// effc++ rule 11
+	void		operator=(CGlobalState&);
+	CGlobalState(const CGlobalState&);
+};
+
+extern CGlobalState gGlobalState;
+
+#endif		//SAVERESTORE_H
diff --git a/sdk/hlsdk/dlls/schedule.h b/sdk/hlsdk/dlls/schedule.h
new file mode 100644
index 0000000..52ea044
--- /dev/null
+++ b/sdk/hlsdk/dlls/schedule.h
@@ -0,0 +1,31 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+//=========================================================
+// Scheduling 
+//=========================================================
+#ifndef	SCHEDULE_H
+#define	SCHEDULE_H
+
+#define	bits_COND_SEE_HATE				( 1 << 1 ) // see something that you hate
+#define bits_COND_SEE_FEAR				( 1 << 2 ) // see something that you are afraid of
+#define bits_COND_SEE_DISLIKE			( 1 << 3 ) // see something that you dislike
+#define bits_COND_SEE_ENEMY				( 1 << 4 ) // target entity is in full view.
+#define bits_COND_LIGHT_DAMAGE			( 1 << 8 ) // hurt a little 
+#define bits_COND_HEAVY_DAMAGE			( 1 << 9 ) // hurt a lot
+#define bits_COND_SEE_CLIENT			( 1 << 21) // see a client
+#define bits_COND_SEE_NEMESIS			( 1 << 22) // see my nemesis
+
+
+#endif	// SCHEDULE_H
diff --git a/sdk/hlsdk/dlls/scriptevent.h b/sdk/hlsdk/dlls/scriptevent.h
new file mode 100644
index 0000000..42377cf
--- /dev/null
+++ b/sdk/hlsdk/dlls/scriptevent.h
@@ -0,0 +1,29 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef SCRIPTEVENT_H
+#define SCRIPTEVENT_H
+
+#define SCRIPT_EVENT_DEAD			1000		// character is now dead
+#define SCRIPT_EVENT_NOINTERRUPT	1001		// does not allow interrupt
+#define SCRIPT_EVENT_CANINTERRUPT	1002		// will allow interrupt
+#define SCRIPT_EVENT_FIREEVENT		1003		// event now fires
+#define SCRIPT_EVENT_SOUND			1004		// Play named wave file (on CHAN_BODY)
+#define SCRIPT_EVENT_SENTENCE		1005		// Play named sentence
+#define SCRIPT_EVENT_INAIR			1006		// Leave the character in air at the end of the sequence (don't find the floor)
+#define SCRIPT_EVENT_ENDANIMATION	1007		// Set the animation by name after the sequence completes
+#define SCRIPT_EVENT_SOUND_VOICE	1008		// Play named wave file (on CHAN_VOICE)
+#define	SCRIPT_EVENT_SENTENCE_RND1	1009		// Play sentence group 25% of the time
+#define SCRIPT_EVENT_NOT_DEAD		1010		// Bring back to life (for life/death sequences)
+#endif   //SCRIPTEVENT_H
diff --git a/sdk/hlsdk/dlls/skill.h b/sdk/hlsdk/dlls/skill.h
new file mode 100644
index 0000000..5ec320c
--- /dev/null
+++ b/sdk/hlsdk/dlls/skill.h
@@ -0,0 +1,147 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+//=========================================================
+// skill.h - skill level concerns
+//=========================================================
+
+struct skilldata_t
+{
+
+	int iSkillLevel; // game skill level
+
+// Monster Health & Damage
+	float	agruntHealth;
+	float agruntDmgPunch;
+
+	float apacheHealth;
+	
+	float barneyHealth;
+
+	float bigmommaHealthFactor;		// Multiply each node's health by this
+	float bigmommaDmgSlash;			// melee attack damage
+	float bigmommaDmgBlast;			// mortar attack damage
+	float bigmommaRadiusBlast;		// mortar attack radius
+
+	float bullsquidHealth;
+	float bullsquidDmgBite;
+	float bullsquidDmgWhip;
+	float bullsquidDmgSpit;
+
+	float gargantuaHealth;
+	float gargantuaDmgSlash;
+	float gargantuaDmgFire;
+	float gargantuaDmgStomp;
+
+	float hassassinHealth;
+
+	float headcrabHealth;
+	float headcrabDmgBite;
+
+	float hgruntHealth;
+	float hgruntDmgKick;
+	float hgruntShotgunPellets;
+	float hgruntGrenadeSpeed;
+
+	float houndeyeHealth;
+	float houndeyeDmgBlast;
+
+	float slaveHealth;
+	float slaveDmgClaw;
+	float slaveDmgClawrake;
+	float slaveDmgZap;
+
+	float ichthyosaurHealth;
+	float ichthyosaurDmgShake;
+
+	float leechHealth;
+	float leechDmgBite;
+
+	float controllerHealth;
+	float controllerDmgZap;
+	float controllerSpeedBall;
+	float controllerDmgBall;
+
+	float nihilanthHealth;
+	float nihilanthZap;
+
+	float scientistHealth;
+
+	float snarkHealth;
+	float snarkDmgBite;
+	float snarkDmgPop;
+
+	float zombieHealth;
+	float zombieDmgOneSlash;
+	float zombieDmgBothSlash;
+
+	float turretHealth;
+	float miniturretHealth;
+	float sentryHealth;
+
+
+// Player Weapons
+	float plrDmgCrowbar;
+	float plrDmg9MM;
+	float plrDmg357;
+	float plrDmgMP5;
+	float plrDmgM203Grenade;
+	float plrDmgBuckshot;
+	float plrDmgCrossbowClient;
+	float plrDmgCrossbowMonster;
+	float plrDmgRPG;
+	float plrDmgGauss;
+	float plrDmgEgonNarrow;
+	float plrDmgEgonWide;
+	float plrDmgHornet;
+	float plrDmgHandGrenade;
+	float plrDmgSatchel;
+	float plrDmgTripmine;
+	
+// weapons shared by monsters
+	float monDmg9MM;
+	float monDmgMP5;
+	float monDmg12MM;
+	float monDmgHornet;
+
+// health/suit charge
+	float suitchargerCapacity;
+	float batteryCapacity;
+	float healthchargerCapacity;
+	float healthkitCapacity;
+	float scientistHeal;
+
+// monster damage adj
+	float monHead;
+	float monChest;
+	float monStomach;
+	float monLeg;
+	float monArm;
+
+// player damage adj
+	float plrHead;
+	float plrChest;
+	float plrStomach;
+	float plrLeg;
+	float plrArm;
+};
+
+extern	DLL_GLOBAL	skilldata_t	gSkillData;
+float GetSkillCvar( char *pName );
+
+extern DLL_GLOBAL int		g_iSkillLevel;
+
+#define SKILL_EASY		1
+#define SKILL_MEDIUM	2
+#define SKILL_HARD		3
diff --git a/sdk/hlsdk/dlls/soundent.h b/sdk/hlsdk/dlls/soundent.h
new file mode 100644
index 0000000..150daac
--- /dev/null
+++ b/sdk/hlsdk/dlls/soundent.h
@@ -0,0 +1,95 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+//=========================================================
+// Soundent.h - the entity that spawns when the world 
+// spawns, and handles the world's active and free sound
+// lists.
+//=========================================================
+
+#define	MAX_WORLD_SOUNDS	64 // maximum number of sounds handled by the world at one time.
+
+#define bits_SOUND_NONE		0
+#define	bits_SOUND_COMBAT	( 1 << 0 )// gunshots, explosions
+#define bits_SOUND_WORLD	( 1 << 1 )// door opening/closing, glass breaking
+#define bits_SOUND_PLAYER	( 1 << 2 )// all noises generated by player. walking, shooting, falling, splashing
+#define bits_SOUND_CARCASS	( 1 << 3 )// dead body
+#define bits_SOUND_MEAT		( 1 << 4 )// gib or pork chop
+#define bits_SOUND_DANGER	( 1 << 5 )// pending danger. Grenade that is about to explode, explosive barrel that is damaged, falling crate
+#define bits_SOUND_GARBAGE	( 1 << 6 )// trash cans, banana peels, old fast food bags.
+
+#define bits_ALL_SOUNDS 0xFFFFFFFF
+
+#define SOUNDLIST_EMPTY	-1
+
+#define SOUNDLISTTYPE_FREE	1// identifiers passed to functions that can operate on either list, to indicate which list to operate on.
+#define SOUNDLISTTYPE_ACTIVE 2
+
+#define	SOUND_NEVER_EXPIRE	-1 // with this set as a sound's ExpireTime, the sound will never expire.
+
+//=========================================================
+// CSound - an instance of a sound in the world.
+//=========================================================
+class CSound
+{
+public:
+
+	void	Clear ( void );
+	void	Reset ( void );
+
+	Vector	m_vecOrigin;	// sound's location in space
+	int		m_iType;		// what type of sound this is
+	int		m_iVolume;		// how loud the sound is
+	float	m_flExpireTime;	// when the sound should be purged from the list
+	int		m_iNext;		// index of next sound in this list ( Active or Free )
+	int		m_iNextAudible;	// temporary link that monsters use to build a list of audible sounds
+
+	BOOL	FIsSound( void );
+	BOOL	FIsScent( void );
+};
+
+//=========================================================
+// CSoundEnt - a single instance of this entity spawns when
+// the world spawns. The SoundEnt's job is to update the 
+// world's Free and Active sound lists.
+//=========================================================
+class CSoundEnt : public CBaseEntity 
+{
+public:
+
+	void Precache ( void );
+	void Spawn( void );
+	void Think( void );
+	void Initialize ( void );
+	
+	static void		InsertSound ( int iType, const Vector &vecOrigin, int iVolume, float flDuration );
+	static void		FreeSound ( int iSound, int iPrevious );
+	static int		ActiveList( void );// return the head of the active list
+	static int		FreeList( void );// return the head of the free list
+	static CSound*	SoundPointerForIndex( int iIndex );// return a pointer for this index in the sound list
+	static int		ClientSoundIndex ( edict_t *pClient );
+
+	BOOL	IsEmpty( void ) { return m_iActiveSound == SOUNDLIST_EMPTY; }
+	int		ISoundsInList ( int iListType );
+	int		IAllocSound ( void );
+	virtual int		ObjectCaps( void ) { return FCAP_DONT_SAVE; }
+	
+	int		m_iFreeSound;	// index of the first sound in the free sound list
+	int		m_iActiveSound; // indes of the first sound in the active sound list
+	int		m_cLastActiveSounds; // keeps track of the number of active sounds at the last update. (for diagnostic work)
+	BOOL	m_fShowReport; // if true, dump information about free/active sounds.
+
+private:
+	CSound		m_SoundPool[ MAX_WORLD_SOUNDS ];
+};
diff --git a/sdk/hlsdk/dlls/spectator.h b/sdk/hlsdk/dlls/spectator.h
new file mode 100644
index 0000000..2f755d6
--- /dev/null
+++ b/sdk/hlsdk/dlls/spectator.h
@@ -0,0 +1,27 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+// Spectator.h
+
+class CBaseSpectator : public CBaseEntity 
+{
+public:
+	void Spawn();
+	void SpectatorConnect(void);
+	void SpectatorDisconnect(void);
+	void SpectatorThink(void);
+
+private:
+	void SpectatorImpulseCommand(void);
+};
diff --git a/sdk/hlsdk/dlls/talkmonster.h b/sdk/hlsdk/dlls/talkmonster.h
new file mode 100644
index 0000000..25c1fc6
--- /dev/null
+++ b/sdk/hlsdk/dlls/talkmonster.h
@@ -0,0 +1,26 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+
+#ifndef TALKMONSTER_H
+#define TALKMONSTER_H
+
+class CTalkMonster : public CBaseMonster
+{
+public:
+	static float g_talkWaitTime;
+
+};
+
+#endif		//TALKMONSTER_H
diff --git a/sdk/hlsdk/dlls/teamplay_gamerules.h b/sdk/hlsdk/dlls/teamplay_gamerules.h
new file mode 100644
index 0000000..5d4246b
--- /dev/null
+++ b/sdk/hlsdk/dlls/teamplay_gamerules.h
@@ -0,0 +1,57 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+//
+// teamplay_gamerules.h
+//
+
+#define MAX_TEAMNAME_LENGTH	16
+#define MAX_TEAMS			32
+
+#define TEAMPLAY_TEAMLISTLENGTH		MAX_TEAMS*MAX_TEAMNAME_LENGTH
+
+class CHalfLifeTeamplay : public CHalfLifeMultiplay
+{
+public:
+	CHalfLifeTeamplay();
+
+	virtual BOOL ClientCommand( CBasePlayer *pPlayer, const char *pcmd );
+	virtual void ClientUserInfoChanged( CBasePlayer *pPlayer, char *infobuffer );
+	virtual BOOL IsTeamplay( void );
+	virtual BOOL FPlayerCanTakeDamage( CBasePlayer *pPlayer, CBaseEntity *pAttacker );
+	virtual int PlayerRelationship( CBaseEntity *pPlayer, CBaseEntity *pTarget );
+	virtual const char *GetTeamID( CBaseEntity *pEntity );
+	virtual BOOL ShouldAutoAim( CBasePlayer *pPlayer, edict_t *target );
+	virtual int IPointsForKill( CBasePlayer *pAttacker, CBasePlayer *pKilled );
+	virtual void InitHUD( CBasePlayer *pl );
+	virtual void DeathNotice( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pevInflictor );
+	virtual const char *GetGameDescription( void ) { return "HL Teamplay"; }  // this is the game name that gets seen in the server browser
+	virtual void UpdateGameMode( CBasePlayer *pPlayer );  // the client needs to be informed of the current game mode
+	virtual void PlayerKilled( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor );
+	virtual void Think ( void );
+	virtual int GetTeamIndex( const char *pTeamName );
+	virtual const char *GetIndexedTeamName( int teamIndex );
+	virtual BOOL IsValidTeam( const char *pTeamName );
+	const char *SetDefaultPlayerTeam( CBasePlayer *pPlayer );
+	virtual void ChangePlayerTeam( CBasePlayer *pPlayer, const char *pTeamName, BOOL bKill, BOOL bGib );
+
+private:
+	void RecountTeams( bool bResendInfo = FALSE );
+	const char *TeamWithFewestPlayers( void );
+
+	BOOL m_DisableDeathMessages;
+	BOOL m_DisableDeathPenalty;
+	BOOL m_teamLimit;				// This means the server set only some teams as valid
+	char m_szTeamList[TEAMPLAY_TEAMLISTLENGTH];
+};
diff --git a/sdk/hlsdk/dlls/trains.h b/sdk/hlsdk/dlls/trains.h
new file mode 100644
index 0000000..87aec76
--- /dev/null
+++ b/sdk/hlsdk/dlls/trains.h
@@ -0,0 +1,127 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef TRAINS_H
+#define TRAINS_H
+
+// Tracktrain spawn flags
+#define SF_TRACKTRAIN_NOPITCH		0x0001
+#define SF_TRACKTRAIN_NOCONTROL		0x0002
+#define SF_TRACKTRAIN_FORWARDONLY	0x0004
+#define SF_TRACKTRAIN_PASSABLE		0x0008
+
+// Spawnflag for CPathTrack
+#define SF_PATH_DISABLED		0x00000001
+#define SF_PATH_FIREONCE		0x00000002
+#define SF_PATH_ALTREVERSE		0x00000004
+#define SF_PATH_DISABLE_TRAIN	0x00000008
+#define SF_PATH_ALTERNATE		0x00008000
+
+// Spawnflags of CPathCorner
+#define SF_CORNER_WAITFORTRIG	0x001
+#define SF_CORNER_TELEPORT		0x002
+#define SF_CORNER_FIREONCE		0x004
+
+//#define PATH_SPARKLE_DEBUG		1	// This makes a particle effect around path_track entities for debugging
+class CPathTrack : public CPointEntity
+{
+public:
+	void		Spawn( void );
+	void		Activate( void );
+	void		KeyValue( KeyValueData* pkvd);
+	
+	void		SetPrevious( CPathTrack *pprevious );
+	void		Link( void );
+	void		Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+	CPathTrack	*ValidPath( CPathTrack *ppath, int testFlag );		// Returns ppath if enabled, NULL otherwise
+	void		Project( CPathTrack *pstart, CPathTrack *pend, Vector *origin, float dist );
+
+	static CPathTrack *Instance( edict_t *pent );
+
+	CPathTrack	*LookAhead( Vector *origin, float dist, int move );
+	CPathTrack	*Nearest( Vector origin );
+
+	CPathTrack	*GetNext( void );
+	CPathTrack	*GetPrevious( void );
+
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	
+	static	TYPEDESCRIPTION m_SaveData[];
+#if PATH_SPARKLE_DEBUG
+	void EXPORT Sparkle(void);
+#endif
+
+	float		m_length;
+	string_t	m_altName;
+	CPathTrack	*m_pnext;
+	CPathTrack	*m_pprevious;
+	CPathTrack	*m_paltpath;
+};
+
+
+class CFuncTrackTrain : public CBaseEntity
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+
+	void Blocked( CBaseEntity *pOther );
+	void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	void KeyValue( KeyValueData* pkvd );
+
+	void EXPORT Next( void );
+	void EXPORT Find( void );
+	void EXPORT NearestPath( void );
+	void EXPORT DeadEnd( void );
+
+	void		NextThink( float thinkTime, BOOL alwaysThink );
+
+	void SetTrack( CPathTrack *track ) { m_ppath = track->Nearest(pev->origin); }
+	void SetControls( entvars_t *pevControls );
+	BOOL OnControls( entvars_t *pev );
+
+	void StopSound ( void );
+	void UpdateSound ( void );
+	
+	static CFuncTrackTrain *Instance( edict_t *pent );
+
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	
+	static	TYPEDESCRIPTION m_SaveData[];
+	virtual int	ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_DIRECTIONAL_USE; }
+
+	virtual void	OverrideReset( void );
+
+	CPathTrack	*m_ppath;
+	float		m_length;
+	float		m_height;
+	float		m_speed;
+	float		m_dir;
+	float		m_startSpeed;
+	Vector		m_controlMins;
+	Vector		m_controlMaxs;
+	int			m_soundPlaying;
+	int			m_sounds;
+	float		m_flVolume;
+	float		m_flBank;
+	float		m_oldSpeed;
+
+private:
+	unsigned short m_usAdjustPitch;
+};
+
+#endif
diff --git a/sdk/hlsdk/dlls/util.h b/sdk/hlsdk/dlls/util.h
new file mode 100644
index 0000000..ddda087
--- /dev/null
+++ b/sdk/hlsdk/dlls/util.h
@@ -0,0 +1,541 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+//
+// Misc utility code
+//
+#include <string.h>
+#ifndef ACTIVITY_H
+#include "activity.h"
+#endif
+
+#ifndef ENGINECALLBACK_H
+#include "enginecallback.h"
+#endif
+inline void MESSAGE_BEGIN( int msg_dest, int msg_type, const float *pOrigin, entvars_t *ent );  // implementation later in this file
+
+extern globalvars_t				*gpGlobals;
+
+// Use this instead of ALLOC_STRING on constant strings
+#define STRING(offset)		(const char *)(gpGlobals->pStringBase + (int)offset)
+#define MAKE_STRING(str)	((int)str - (int)STRING(0))
+
+inline edict_t *FIND_ENTITY_BY_CLASSNAME(edict_t *entStart, const char *pszName) 
+{
+	return FIND_ENTITY_BY_STRING(entStart, "classname", pszName);
+}	
+
+inline edict_t *FIND_ENTITY_BY_TARGETNAME(edict_t *entStart, const char *pszName) 
+{
+	return FIND_ENTITY_BY_STRING(entStart, "targetname", pszName);
+}	
+
+// for doing a reverse lookup. Say you have a door, and want to find its button.
+inline edict_t *FIND_ENTITY_BY_TARGET(edict_t *entStart, const char *pszName) 
+{
+	return FIND_ENTITY_BY_STRING(entStart, "target", pszName);
+}	
+
+// Keeps clutter down a bit, when writing key-value pairs
+#define WRITEKEY_INT(pf, szKeyName, iKeyValue) ENGINE_FPRINTF(pf, "\"%s\" \"%d\"\n", szKeyName, iKeyValue)
+#define WRITEKEY_FLOAT(pf, szKeyName, flKeyValue)								\
+		ENGINE_FPRINTF(pf, "\"%s\" \"%f\"\n", szKeyName, flKeyValue)
+#define WRITEKEY_STRING(pf, szKeyName, szKeyValue)								\
+		ENGINE_FPRINTF(pf, "\"%s\" \"%s\"\n", szKeyName, szKeyValue)
+#define WRITEKEY_VECTOR(pf, szKeyName, flX, flY, flZ)							\
+		ENGINE_FPRINTF(pf, "\"%s\" \"%f %f %f\"\n", szKeyName, flX, flY, flZ)
+
+// Keeps clutter down a bit, when using a float as a bit-vector
+#define SetBits(flBitVector, bits)		((flBitVector) = (int)(flBitVector) | (bits))
+#define ClearBits(flBitVector, bits)	((flBitVector) = (int)(flBitVector) & ~(bits))
+#define FBitSet(flBitVector, bit)		((int)(flBitVector) & (bit))
+
+// Makes these more explicit, and easier to find
+#define FILE_GLOBAL static
+#define DLL_GLOBAL
+
+// Until we figure out why "const" gives the compiler problems, we'll just have to use
+// this bogus "empty" define to mark things as constant.
+#define CONSTANT
+
+// More explicit than "int"
+typedef int EOFFSET;
+
+// In case it's not alread defined
+typedef int BOOL;
+
+// In case this ever changes
+#define M_PI			3.14159265358979323846
+
+// Keeps clutter down a bit, when declaring external entity/global method prototypes
+#define DECLARE_GLOBAL_METHOD(MethodName)  extern void DLLEXPORT MethodName( void )
+#define GLOBAL_METHOD(funcname)					void DLLEXPORT funcname(void)
+
+// This is the glue that hooks .MAP entity class names to our CPP classes
+// The _declspec forces them to be exported by name so we can do a lookup with GetProcAddress()
+// The function is used to intialize / allocate the object for the entity
+#ifdef _WIN32
+#define LINK_ENTITY_TO_CLASS(mapClassName,DLLClassName) \
+	extern "C" _declspec( dllexport ) void mapClassName( entvars_t *pev ); \
+	void mapClassName( entvars_t *pev ) { GetClassPtr( (DLLClassName *)pev ); }
+#else
+#define LINK_ENTITY_TO_CLASS(mapClassName,DLLClassName) extern "C" void mapClassName( entvars_t *pev ); void mapClassName( entvars_t *pev ) { GetClassPtr( (DLLClassName *)pev ); }
+#endif
+
+
+//
+// Conversion among the three types of "entity", including identity-conversions.
+//
+#ifdef DEBUG
+	extern edict_t *DBG_EntOfVars(const entvars_t *pev);
+	inline edict_t *ENT(const entvars_t *pev)	{ return DBG_EntOfVars(pev); }
+#else
+	inline edict_t *ENT(const entvars_t *pev)	{ return pev->pContainingEntity; }
+#endif
+inline edict_t *ENT(edict_t *pent)		{ return pent; }
+inline edict_t *ENT(EOFFSET eoffset)			{ return (*g_engfuncs.pfnPEntityOfEntOffset)(eoffset); }
+inline EOFFSET OFFSET(EOFFSET eoffset)			{ return eoffset; }
+inline EOFFSET OFFSET(const edict_t *pent)	
+{ 
+#ifdef _DEBUG
+	if ( !pent )
+		ALERT( at_error, "Bad ent in OFFSET()\n" );
+#endif
+	return (*g_engfuncs.pfnEntOffsetOfPEntity)(pent); 
+}
+inline EOFFSET OFFSET(entvars_t *pev)				
+{ 
+#ifdef _DEBUG
+	if ( !pev )
+		ALERT( at_error, "Bad pev in OFFSET()\n" );
+#endif
+	return OFFSET(ENT(pev)); 
+}
+inline entvars_t *VARS(entvars_t *pev)					{ return pev; }
+
+inline entvars_t *VARS(edict_t *pent)			
+{ 
+	if ( !pent )
+		return NULL;
+
+	return &pent->v; 
+}
+
+inline entvars_t* VARS(EOFFSET eoffset)				{ return VARS(ENT(eoffset)); }
+inline int	  ENTINDEX(edict_t *pEdict)			{ return (*g_engfuncs.pfnIndexOfEdict)(pEdict); }
+inline edict_t* INDEXENT( int iEdictNum )		{ return (*g_engfuncs.pfnPEntityOfEntIndex)(iEdictNum); }
+inline void MESSAGE_BEGIN( int msg_dest, int msg_type, const float *pOrigin, entvars_t *ent ) {
+	(*g_engfuncs.pfnMessageBegin)(msg_dest, msg_type, pOrigin, ENT(ent));
+}
+
+// Testing the three types of "entity" for nullity
+#define eoNullEntity 0
+inline BOOL FNullEnt(EOFFSET eoffset)			{ return eoffset == 0; }
+inline BOOL FNullEnt(const edict_t* pent)	{ return pent == NULL || FNullEnt(OFFSET(pent)); }
+inline BOOL FNullEnt(entvars_t* pev)				{ return pev == NULL || FNullEnt(OFFSET(pev)); }
+
+// Testing strings for nullity
+#define iStringNull 0
+inline BOOL FStringNull(int iString)			{ return iString == iStringNull; }
+
+#define cchMapNameMost 32
+
+// Dot products for view cone checking
+#define VIEW_FIELD_FULL		(float)-1.0 // +-180 degrees
+#define	VIEW_FIELD_WIDE		(float)-0.7 // +-135 degrees 0.1 // +-85 degrees, used for full FOV checks 
+#define	VIEW_FIELD_NARROW	(float)0.7 // +-45 degrees, more narrow check used to set up ranged attacks
+#define	VIEW_FIELD_ULTRA_NARROW	(float)0.9 // +-25 degrees, more narrow check used to set up ranged attacks
+
+// All monsters need this data
+#define		DONT_BLEED			-1
+#define		BLOOD_COLOR_RED		(BYTE)247
+#define		BLOOD_COLOR_YELLOW	(BYTE)195
+#define		BLOOD_COLOR_GREEN	BLOOD_COLOR_YELLOW
+
+typedef enum 
+{
+
+	MONSTERSTATE_NONE = 0,
+	MONSTERSTATE_IDLE,
+	MONSTERSTATE_COMBAT,
+	MONSTERSTATE_ALERT,
+	MONSTERSTATE_HUNT,
+	MONSTERSTATE_PRONE,
+	MONSTERSTATE_SCRIPT,
+	MONSTERSTATE_PLAYDEAD,
+	MONSTERSTATE_DEAD
+
+} MONSTERSTATE;
+
+
+
+// Things that toggle (buttons/triggers/doors) need this
+typedef enum
+	{
+	TS_AT_TOP,
+	TS_AT_BOTTOM,
+	TS_GOING_UP,
+	TS_GOING_DOWN
+	} TOGGLE_STATE;
+
+// Misc useful
+inline BOOL FStrEq(const char*sz1, const char*sz2)
+	{ return (strcmp(sz1, sz2) == 0); }
+inline BOOL FClassnameIs(edict_t* pent, const char* szClassname)
+	{ return FStrEq(STRING(VARS(pent)->classname), szClassname); }
+inline BOOL FClassnameIs(entvars_t* pev, const char* szClassname)
+	{ return FStrEq(STRING(pev->classname), szClassname); }
+
+class CBaseEntity;
+
+// Misc. Prototypes
+extern void			UTIL_SetSize			(entvars_t* pev, const Vector &vecMin, const Vector &vecMax);
+extern float		UTIL_VecToYaw			(const Vector &vec);
+extern Vector		UTIL_VecToAngles		(const Vector &vec);
+extern float		UTIL_AngleMod			(float a);
+extern float		UTIL_AngleDiff			( float destAngle, float srcAngle );
+
+extern CBaseEntity	*UTIL_FindEntityInSphere(CBaseEntity *pStartEntity, const Vector &vecCenter, float flRadius);
+extern CBaseEntity	*UTIL_FindEntityByString(CBaseEntity *pStartEntity, const char *szKeyword, const char *szValue );
+extern CBaseEntity	*UTIL_FindEntityByClassname(CBaseEntity *pStartEntity, const char *szName );
+extern CBaseEntity	*UTIL_FindEntityByTargetname(CBaseEntity *pStartEntity, const char *szName );
+extern CBaseEntity	*UTIL_FindEntityGeneric(const char *szName, Vector &vecSrc, float flRadius );
+
+// returns a CBaseEntity pointer to a player by index.  Only returns if the player is spawned and connected
+// otherwise returns NULL
+// Index is 1 based
+extern CBaseEntity	*UTIL_PlayerByIndex( int playerIndex );
+
+#define UTIL_EntitiesInPVS(pent)			(*g_engfuncs.pfnEntitiesInPVS)(pent)
+extern void			UTIL_MakeVectors		(const Vector &vecAngles);
+
+// Pass in an array of pointers and an array size, it fills the array and returns the number inserted
+extern int			UTIL_MonstersInSphere( CBaseEntity **pList, int listMax, const Vector &center, float radius );
+extern int			UTIL_EntitiesInBox( CBaseEntity **pList, int listMax, const Vector &mins, const Vector &maxs, int flagMask );
+
+inline void UTIL_MakeVectorsPrivate( const Vector &vecAngles, float *p_vForward, float *p_vRight, float *p_vUp )
+{
+	g_engfuncs.pfnAngleVectors( vecAngles, p_vForward, p_vRight, p_vUp );
+}
+
+extern void			UTIL_MakeAimVectors		( const Vector &vecAngles ); // like MakeVectors, but assumes pitch isn't inverted
+extern void			UTIL_MakeInvVectors		( const Vector &vec, globalvars_t *pgv );
+
+extern void			UTIL_SetOrigin			( entvars_t* pev, const Vector &vecOrigin );
+extern void			UTIL_EmitAmbientSound	( edict_t *entity, const Vector &vecOrigin, const char *samp, float vol, float attenuation, int fFlags, int pitch );
+extern void			UTIL_ParticleEffect		( const Vector &vecOrigin, const Vector &vecDirection, ULONG ulColor, ULONG ulCount );
+extern void			UTIL_ScreenShake		( const Vector &center, float amplitude, float frequency, float duration, float radius );
+extern void			UTIL_ScreenShakeAll		( const Vector &center, float amplitude, float frequency, float duration );
+extern void			UTIL_ShowMessage		( const char *pString, CBaseEntity *pPlayer );
+extern void			UTIL_ShowMessageAll		( const char *pString );
+extern void			UTIL_ScreenFadeAll		( const Vector &color, float fadeTime, float holdTime, int alpha, int flags );
+extern void			UTIL_ScreenFade			( CBaseEntity *pEntity, const Vector &color, float fadeTime, float fadeHold, int alpha, int flags );
+
+typedef enum { ignore_monsters=1, dont_ignore_monsters=0, missile=2 } IGNORE_MONSTERS;
+typedef enum { ignore_glass=1, dont_ignore_glass=0 } IGNORE_GLASS;
+extern void			UTIL_TraceLine			(const Vector &vecStart, const Vector &vecEnd, IGNORE_MONSTERS igmon, edict_t *pentIgnore, TraceResult *ptr);
+extern void			UTIL_TraceLine			(const Vector &vecStart, const Vector &vecEnd, IGNORE_MONSTERS igmon, IGNORE_GLASS ignoreGlass, edict_t *pentIgnore, TraceResult *ptr);
+typedef enum { point_hull=0, human_hull=1, large_hull=2, head_hull=3 } __HLSDK_HULL_TYPE;
+extern void			UTIL_TraceHull			(const Vector &vecStart, const Vector &vecEnd, IGNORE_MONSTERS igmon, int hullNumber, edict_t *pentIgnore, TraceResult *ptr);
+extern TraceResult	UTIL_GetGlobalTrace		(void);
+extern void			UTIL_TraceModel			(const Vector &vecStart, const Vector &vecEnd, int hullNumber, edict_t *pentModel, TraceResult *ptr);
+extern Vector		UTIL_GetAimVector		(edict_t* pent, float flSpeed);
+extern int			UTIL_PointContents		(const Vector &vec);
+
+extern int			UTIL_IsMasterTriggered	(string_t sMaster, CBaseEntity *pActivator);
+extern void			UTIL_BloodStream( const Vector &origin, const Vector &direction, int color, int amount );
+extern void			UTIL_BloodDrips( const Vector &origin, const Vector &direction, int color, int amount );
+extern Vector		UTIL_RandomBloodVector( void );
+extern BOOL			UTIL_ShouldShowBlood( int bloodColor );
+extern void			UTIL_BloodDecalTrace( TraceResult *pTrace, int bloodColor );
+extern void			UTIL_DecalTrace( TraceResult *pTrace, int decalNumber );
+extern void			UTIL_PlayerDecalTrace( TraceResult *pTrace, int playernum, int decalNumber, BOOL bIsCustom );
+extern void			UTIL_GunshotDecalTrace( TraceResult *pTrace, int decalNumber );
+extern void			UTIL_Sparks( const Vector &position );
+extern void			UTIL_Ricochet( const Vector &position, float scale );
+extern void			UTIL_StringToVector( float *pVector, const char *pString );
+extern void			UTIL_StringToIntArray( int *pVector, int count, const char *pString );
+extern Vector		UTIL_ClampVectorToBox( const Vector &input, const Vector &clampSize );
+extern float		UTIL_Approach( float target, float value, float speed );
+extern float		UTIL_ApproachAngle( float target, float value, float speed );
+extern float		UTIL_AngleDistance( float next, float cur );
+
+extern char			*UTIL_VarArgs( char *format, ... );
+extern void			UTIL_Remove( CBaseEntity *pEntity );
+extern BOOL			UTIL_IsValidEntity( edict_t *pent );
+extern BOOL			UTIL_TeamsMatch( const char *pTeamName1, const char *pTeamName2 );
+
+// Use for ease-in, ease-out style interpolation (accel/decel)
+extern float		UTIL_SplineFraction( float value, float scale );
+
+// Search for water transition along a vertical line
+extern float		UTIL_WaterLevel( const Vector &position, float minz, float maxz );
+extern void			UTIL_Bubbles( Vector mins, Vector maxs, int count );
+extern void			UTIL_BubbleTrail( Vector from, Vector to, int count );
+
+// allows precacheing of other entities
+extern void			UTIL_PrecacheOther( const char *szClassname );
+
+// prints a message to each client
+extern void			UTIL_ClientPrintAll( int msg_dest, const char *msg_name, const char *param1 = NULL, const char *param2 = NULL, const char *param3 = NULL, const char *param4 = NULL );
+inline void			UTIL_CenterPrintAll( const char *msg_name, const char *param1 = NULL, const char *param2 = NULL, const char *param3 = NULL, const char *param4 = NULL ) 
+{
+	UTIL_ClientPrintAll( HUD_PRINTCENTER, msg_name, param1, param2, param3, param4 );
+}
+
+class CBasePlayerItem;
+class CBasePlayer;
+extern BOOL UTIL_GetNextBestWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon );
+
+// prints messages through the HUD
+extern void ClientPrint( entvars_t *client, int msg_dest, const char *msg_name, const char *param1 = NULL, const char *param2 = NULL, const char *param3 = NULL, const char *param4 = NULL );
+
+// prints a message to the HUD say (chat)
+extern void			UTIL_SayText( const char *pText, CBaseEntity *pEntity );
+extern void			UTIL_SayTextAll( const char *pText, CBaseEntity *pEntity );
+
+
+typedef struct hudtextparms_s
+{
+	float		x;
+	float		y;
+	int			effect;
+	byte		r1, g1, b1, a1;
+	byte		r2, g2, b2, a2;
+	float		fadeinTime;
+	float		fadeoutTime;
+	float		holdTime;
+	float		fxTime;
+	int			channel;
+} hudtextparms_t;
+
+// prints as transparent 'title' to the HUD
+extern void			UTIL_HudMessageAll( const hudtextparms_t &textparms, const char *pMessage );
+extern void			UTIL_HudMessage( CBaseEntity *pEntity, const hudtextparms_t &textparms, const char *pMessage );
+
+// for handy use with ClientPrint params
+extern char *UTIL_dtos1( int d );
+extern char *UTIL_dtos2( int d );
+extern char *UTIL_dtos3( int d );
+extern char *UTIL_dtos4( int d );
+
+// Writes message to console with timestamp and FragLog header.
+extern void			UTIL_LogPrintf( char *fmt, ... );
+
+// Sorta like FInViewCone, but for nonmonsters. 
+extern float UTIL_DotPoints ( const Vector &vecSrc, const Vector &vecCheck, const Vector &vecDir );
+
+extern void UTIL_StripToken( const char *pKey, char *pDest );// for redundant keynames
+
+// Misc functions
+extern void SetMovedir(entvars_t* pev);
+extern Vector VecBModelOrigin( entvars_t* pevBModel );
+extern int BuildChangeList( LEVELLIST *pLevelList, int maxList );
+
+//
+// How did I ever live without ASSERT?
+//
+#ifdef	DEBUG
+void DBG_AssertFunction(BOOL fExpr, const char* szExpr, const char* szFile, int szLine, const char* szMessage);
+#define ASSERT(f)		DBG_AssertFunction(f, #f, __FILE__, __LINE__, NULL)
+#define ASSERTSZ(f, sz)	DBG_AssertFunction(f, #f, __FILE__, __LINE__, sz)
+#else	// !DEBUG
+#define ASSERT(f)
+#define ASSERTSZ(f, sz)
+#endif	// !DEBUG
+
+
+extern DLL_GLOBAL const Vector g_vecZero;
+
+//
+// Constants that were used only by QC (maybe not used at all now)
+//
+// Un-comment only as needed
+//
+#define LANGUAGE_ENGLISH				0
+#define LANGUAGE_GERMAN					1
+#define LANGUAGE_FRENCH					2
+#define LANGUAGE_BRITISH				3
+
+extern DLL_GLOBAL int			g_Language;
+
+#define AMBIENT_SOUND_STATIC			0	// medium radius attenuation
+#define AMBIENT_SOUND_EVERYWHERE		1
+#define AMBIENT_SOUND_SMALLRADIUS		2
+#define AMBIENT_SOUND_MEDIUMRADIUS		4
+#define AMBIENT_SOUND_LARGERADIUS		8
+#define AMBIENT_SOUND_START_SILENT		16
+#define AMBIENT_SOUND_NOT_LOOPING		32
+
+#define SPEAKER_START_SILENT			1	// wait for trigger 'on' to start announcements
+
+#define SND_SPAWNING		(1<<8)		// duplicated in protocol.h we're spawing, used in some cases for ambients 
+#define SND_STOP			(1<<5)		// duplicated in protocol.h stop sound
+#define SND_CHANGE_VOL		(1<<6)		// duplicated in protocol.h change sound vol
+#define SND_CHANGE_PITCH	(1<<7)		// duplicated in protocol.h change sound pitch
+
+#define	LFO_SQUARE			1
+#define LFO_TRIANGLE		2
+#define LFO_RANDOM			3
+
+// func_rotating
+#define SF_BRUSH_ROTATE_Y_AXIS		0
+#define SF_BRUSH_ROTATE_INSTANT		1
+#define SF_BRUSH_ROTATE_BACKWARDS	2
+#define SF_BRUSH_ROTATE_Z_AXIS		4
+#define SF_BRUSH_ROTATE_X_AXIS		8
+#define SF_PENDULUM_AUTO_RETURN		16
+#define	SF_PENDULUM_PASSABLE		32
+
+
+#define SF_BRUSH_ROTATE_SMALLRADIUS	128
+#define SF_BRUSH_ROTATE_MEDIUMRADIUS 256
+#define SF_BRUSH_ROTATE_LARGERADIUS 512
+
+#define PUSH_BLOCK_ONLY_X	1
+#define PUSH_BLOCK_ONLY_Y	2
+
+#define VEC_HULL_MIN		Vector(-16, -16, -36)
+#define VEC_HULL_MAX		Vector( 16,  16,  36)
+#define VEC_HUMAN_HULL_MIN	Vector( -16, -16, 0 )
+#define VEC_HUMAN_HULL_MAX	Vector( 16, 16, 72 )
+#define VEC_HUMAN_HULL_DUCK	Vector( 16, 16, 36 )
+
+#define VEC_VIEW			Vector( 0, 0, 28 )
+
+#define VEC_DUCK_HULL_MIN	Vector(-16, -16, -18 )
+#define VEC_DUCK_HULL_MAX	Vector( 16,  16,  18)
+#define VEC_DUCK_VIEW		Vector( 0, 0, 12 )
+
+#define SVC_TEMPENTITY		23
+#define SVC_INTERMISSION	30
+#define SVC_CDTRACK			32
+#define SVC_WEAPONANIM		35
+#define SVC_ROOMTYPE		37
+#define	SVC_DIRECTOR		51
+
+
+
+// triggers
+#define	SF_TRIGGER_ALLOWMONSTERS	1// monsters allowed to fire this trigger
+#define	SF_TRIGGER_NOCLIENTS		2// players not allowed to fire this trigger
+#define SF_TRIGGER_PUSHABLES		4// only pushables can fire this trigger
+
+// func breakable
+#define SF_BREAK_TRIGGER_ONLY	1// may only be broken by trigger
+#define	SF_BREAK_TOUCH			2// can be 'crashed through' by running player (plate glass)
+#define SF_BREAK_PRESSURE		4// can be broken by a player standing on it
+#define SF_BREAK_CROWBAR		256// instant break if hit with crowbar
+
+// func_pushable (it's also func_breakable, so don't collide with those flags)
+#define SF_PUSH_BREAKABLE		128
+
+#define SF_LIGHT_START_OFF		1
+
+#define SPAWNFLAG_NOMESSAGE	1
+#define SPAWNFLAG_NOTOUCH	1
+#define SPAWNFLAG_DROIDONLY	4
+
+#define SPAWNFLAG_USEONLY	1		// can't be touched, must be used (buttons)
+
+#define TELE_PLAYER_ONLY	1
+#define TELE_SILENT			2
+
+#define SF_TRIG_PUSH_ONCE		1
+
+
+// Sound Utilities
+
+// sentence groups
+#define CBSENTENCENAME_MAX 16
+#define CVOXFILESENTENCEMAX		1536		// max number of sentences in game. NOTE: this must match
+											// CVOXFILESENTENCEMAX in engine\sound.h!!!
+
+extern char gszallsentencenames[CVOXFILESENTENCEMAX][CBSENTENCENAME_MAX];
+extern int gcallsentences;
+
+int USENTENCEG_Pick(int isentenceg, char *szfound);
+int USENTENCEG_PickSequential(int isentenceg, char *szfound, int ipick, int freset);
+void USENTENCEG_InitLRU(unsigned char *plru, int count);
+
+void SENTENCEG_Init();
+void SENTENCEG_Stop(edict_t *entity, int isentenceg, int ipick);
+int SENTENCEG_PlayRndI(edict_t *entity, int isentenceg, float volume, float attenuation, int flags, int pitch);
+int SENTENCEG_PlayRndSz(edict_t *entity, const char *szrootname, float volume, float attenuation, int flags, int pitch);
+int SENTENCEG_PlaySequentialSz(edict_t *entity, const char *szrootname, float volume, float attenuation, int flags, int pitch, int ipick, int freset);
+int SENTENCEG_GetIndex(const char *szrootname);
+int SENTENCEG_Lookup(const char *sample, char *sentencenum);
+
+void TEXTURETYPE_Init();
+char TEXTURETYPE_Find(char *name);
+float TEXTURETYPE_PlaySound(TraceResult *ptr,  Vector vecSrc, Vector vecEnd, int iBulletType);
+
+// NOTE: use EMIT_SOUND_DYN to set the pitch of a sound. Pitch of 100
+// is no pitch shift.  Pitch > 100 up to 255 is a higher pitch, pitch < 100
+// down to 1 is a lower pitch.   150 to 70 is the realistic range.
+// EMIT_SOUND_DYN with pitch != 100 should be used sparingly, as it's not quite as
+// fast as EMIT_SOUND (the pitchshift mixer is not native coded).
+
+void EMIT_SOUND_DYN(edict_t *entity, int channel, const char *sample, float volume, float attenuation,
+						   int flags, int pitch);
+
+
+inline void EMIT_SOUND(edict_t *entity, int channel, const char *sample, float volume, float attenuation)
+{
+	EMIT_SOUND_DYN(entity, channel, sample, volume, attenuation, 0, PITCH_NORM);
+}
+
+inline void STOP_SOUND(edict_t *entity, int channel, const char *sample)
+{
+	EMIT_SOUND_DYN(entity, channel, sample, 0, 0, SND_STOP, PITCH_NORM);
+}
+
+void EMIT_SOUND_SUIT(edict_t *entity, const char *sample);
+void EMIT_GROUPID_SUIT(edict_t *entity, int isentenceg);
+void EMIT_GROUPNAME_SUIT(edict_t *entity, const char *groupname);
+
+#define PRECACHE_SOUND_ARRAY( a ) \
+	{ for (int i = 0; i < ARRAYSIZE( a ); i++ ) PRECACHE_SOUND((char *) a [i]); }
+
+#define EMIT_SOUND_ARRAY_DYN( chan, array ) \
+	EMIT_SOUND_DYN ( ENT(pev), chan , array [ RANDOM_LONG(0,ARRAYSIZE( array )-1) ], 1.0, ATTN_NORM, 0, RANDOM_LONG(95,105) ); 
+
+#define RANDOM_SOUND_ARRAY( array ) (array) [ RANDOM_LONG(0,ARRAYSIZE( (array) )-1) ]
+
+#define PLAYBACK_EVENT( flags, who, index ) PLAYBACK_EVENT_FULL( flags, who, index, 0, (float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, 0, 0, 0, 0 );
+#define PLAYBACK_EVENT_DELAY( flags, who, index, delay ) PLAYBACK_EVENT_FULL( flags, who, index, delay, (float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, 0, 0, 0, 0 );
+
+#define GROUP_OP_AND	0
+#define GROUP_OP_NAND	1
+
+extern int g_groupmask;
+extern int g_groupop;
+
+class UTIL_GroupTrace
+{
+public:
+	UTIL_GroupTrace( int groupmask, int op );
+	~UTIL_GroupTrace( void );
+
+private:
+	int m_oldgroupmask, m_oldgroupop;
+};
+
+void UTIL_SetGroupTrace( int groupmask, int op );
+void UTIL_UnsetGroupTrace( void );
+
+int UTIL_SharedRandomLong( unsigned int seed, int low, int high );
+float UTIL_SharedRandomFloat( unsigned int seed, float low, float high );
+
+float UTIL_WeaponTimeBase( void );
diff --git a/sdk/hlsdk/dlls/vector.h b/sdk/hlsdk/dlls/vector.h
new file mode 100644
index 0000000..e51c859
--- /dev/null
+++ b/sdk/hlsdk/dlls/vector.h
@@ -0,0 +1,112 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef VECTOR_H
+#define VECTOR_H
+
+//=========================================================
+// 2DVector - used for many pathfinding and many other 
+// operations that are treated as planar rather than 3d.
+//=========================================================
+class Vector2D
+{
+public:
+	inline Vector2D(void): x(0.0), y(0.0)							{ }
+	inline Vector2D(float X, float Y): x(0.0), y(0.0)				{ x = X; y = Y; }
+	inline Vector2D operator+(const Vector2D& v)	const	{ return Vector2D(x+v.x, y+v.y);	}
+	inline Vector2D operator-(const Vector2D& v)	const	{ return Vector2D(x-v.x, y-v.y);	}
+	inline Vector2D operator*(float fl)				const	{ return Vector2D(x*fl, y*fl);	}
+	inline Vector2D operator/(float fl)				const	{ return Vector2D(x/fl, y/fl);	}
+	
+	inline float Length(void)						const	{ return sqrt(x*x + y*y );		}
+
+	inline Vector2D Normalize ( void ) const
+	{
+		// Vector2D vec2;
+
+		float flLen = Length();
+		if ( flLen == 0 )
+		{
+			return Vector2D( 0, 0 );
+		}
+		else
+		{
+			flLen = 1 / flLen;
+			return Vector2D( x * flLen, y * flLen );
+		}
+	}
+
+	vec_t	x, y;
+};
+
+inline float DotProduct(const Vector2D& a, const Vector2D& b) { return( a.x*b.x + a.y*b.y ); }
+inline Vector2D operator*(float fl, const Vector2D& v)	{ return v * fl; }
+
+//=========================================================
+// 3D Vector
+//=========================================================
+class Vector						// same data-layout as engine's vec3_t,
+{								//		which is a vec_t[3]
+public:
+	// Construction/destruction
+	inline Vector(void): x(0.0), y(0.0), z(0.0)					{ }
+	inline Vector(float X, float Y, float Z): x(0.0), y(0.0), z(0.0)	{ x = X; y = Y; z = Z;				}
+	//inline Vector(double X, double Y, double Z)		{ x = (float)X; y = (float)Y; z = (float)Z;	}
+	//inline Vector(int X, int Y, int Z)				{ x = (float)X; y = (float)Y; z = (float)Z;	}
+	inline Vector(const Vector& v): x(0.0), y(0.0), z(0.0)		{ x = v.x; y = v.y; z = v.z;				} 
+	inline Vector(float rgfl[3]): x(0.0), y(0.0), z(0.0)		{ x = rgfl[0]; y = rgfl[1]; z = rgfl[2];	}
+
+	// Operators
+	inline Vector operator-(void) const				{ return Vector(-x,-y,-z);				}
+	inline int operator==(const Vector& v) const	{ return x==v.x && y==v.y && z==v.z;	}
+	inline int operator!=(const Vector& v) const	{ return !(*this==v);					}
+	inline Vector operator+(const Vector& v) const	{ return Vector(x+v.x, y+v.y, z+v.z);	}
+	inline Vector operator-(const Vector& v) const	{ return Vector(x-v.x, y-v.y, z-v.z);	}
+	inline Vector operator*(float fl) const			{ return Vector(x*fl, y*fl, z*fl);		}
+	inline Vector operator/(float fl) const			{ return Vector(x/fl, y/fl, z/fl);		}
+	
+	// Methods
+	inline void CopyToArray(float* rgfl) const		{ rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
+	inline float Length(void) const					{ return sqrt(x*x + y*y + z*z); }
+	operator float *()								{ return &x; } // Vectors will now automatically convert to float * when needed
+	operator const float *() const					{ return &x; } // Vectors will now automatically convert to float * when needed
+	inline Vector Normalize(void) const
+	{
+		float flLen = Length();
+		if (flLen == 0) return Vector(0,0,1); // ????
+		flLen = 1 / flLen;
+		return Vector(x * flLen, y * flLen, z * flLen);
+	}
+
+	inline Vector2D Make2D ( void ) const
+	{
+		Vector2D	Vec2;
+
+		Vec2.x = x;
+		Vec2.y = y;
+
+		return Vec2;
+	}
+	inline float Length2D(void) const					{ return sqrt(x*x + y*y); }
+
+	// Members
+	vec_t x, y, z;
+};
+inline Vector operator*(float fl, const Vector& v)	{ return v * fl; }
+inline float DotProduct(const Vector& a, const Vector& b) { return(a.x*b.x+a.y*b.y+a.z*b.z); }
+inline Vector CrossProduct(const Vector& a, const Vector& b) { return Vector( a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x ); }
+
+
+
+#endif
diff --git a/sdk/hlsdk/dlls/weapons.h b/sdk/hlsdk/dlls/weapons.h
new file mode 100644
index 0000000..8194a4d
--- /dev/null
+++ b/sdk/hlsdk/dlls/weapons.h
@@ -0,0 +1,1015 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef WEAPONS_H
+#define WEAPONS_H
+
+#include "effects.h"
+
+class CBasePlayer;
+extern int gmsgWeapPickup;
+
+void DeactivateSatchels( CBasePlayer *pOwner );
+
+// Contact Grenade / Timed grenade / Satchel Charge
+class CGrenade : public CBaseMonster
+{
+public:
+	void Spawn( void );
+
+	typedef enum { SATCHEL_DETONATE = 0, SATCHEL_RELEASE } SATCHELCODE;
+
+	static CGrenade *ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time );
+	static CGrenade *ShootContact( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity );
+	static CGrenade *ShootSatchelCharge( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity );
+	static void UseSatchelCharges( entvars_t *pevOwner, SATCHELCODE code );
+
+	void Explode( Vector vecSrc, Vector vecAim );
+	void Explode( TraceResult *pTrace, int bitsDamageType );
+	void EXPORT Smoke( void );
+
+	void EXPORT BounceTouch( CBaseEntity *pOther );
+	void EXPORT SlideTouch( CBaseEntity *pOther );
+	void EXPORT ExplodeTouch( CBaseEntity *pOther );
+	void EXPORT DangerSoundThink( void );
+	void EXPORT PreDetonate( void );
+	void EXPORT Detonate( void );
+	void EXPORT DetonateUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	void EXPORT TumbleThink( void );
+
+	virtual void BounceSound( void );
+	virtual int	BloodColor( void ) { return DONT_BLEED; }
+	virtual void Killed( entvars_t *pevAttacker, int iGib );
+
+	BOOL m_fRegisteredSound;// whether or not this grenade has issued its DANGER sound to the world sound list yet.
+};
+
+
+// constant items
+#define ITEM_HEALTHKIT		1
+#define ITEM_ANTIDOTE		2
+#define ITEM_SECURITY		3
+#define ITEM_BATTERY		4
+
+#define WEAPON_NONE				0
+#define WEAPON_CROWBAR			1
+#define	WEAPON_GLOCK			2
+#define WEAPON_PYTHON			3
+#define WEAPON_MP5				4
+#define WEAPON_CHAINGUN			5
+#define WEAPON_CROSSBOW			6
+#define WEAPON_SHOTGUN			7
+#define WEAPON_RPG				8
+#define WEAPON_GAUSS			9
+#define WEAPON_EGON				10
+#define WEAPON_HORNETGUN		11
+#define WEAPON_HANDGRENADE		12
+#define WEAPON_TRIPMINE			13
+#define	WEAPON_SATCHEL			14
+#define	WEAPON_SNARK			15
+
+#define WEAPON_ALLWEAPONS		(~(1<<WEAPON_SUIT))
+
+#define WEAPON_SUIT				31	// ?????
+
+#define MAX_WEAPONS			32
+
+
+#define MAX_NORMAL_BATTERY	100
+
+
+// weapon weight factors (for auto-switching)   (-1 = noswitch)
+#define CROWBAR_WEIGHT		0
+#define GLOCK_WEIGHT		10
+#define PYTHON_WEIGHT		15
+#define MP5_WEIGHT			15
+#define SHOTGUN_WEIGHT		15
+#define CROSSBOW_WEIGHT		10
+#define RPG_WEIGHT			20
+#define GAUSS_WEIGHT		20
+#define EGON_WEIGHT			20
+#define HORNETGUN_WEIGHT	10
+#define HANDGRENADE_WEIGHT	5
+#define SNARK_WEIGHT		5
+#define SATCHEL_WEIGHT		-10
+#define TRIPMINE_WEIGHT		-10
+
+
+// weapon clip/carry ammo capacities
+#define URANIUM_MAX_CARRY		100
+#define	_9MM_MAX_CARRY			250
+#define _357_MAX_CARRY			36
+#define BUCKSHOT_MAX_CARRY		125
+#define BOLT_MAX_CARRY			50
+#define ROCKET_MAX_CARRY		5
+#define HANDGRENADE_MAX_CARRY	10
+#define SATCHEL_MAX_CARRY		5
+#define TRIPMINE_MAX_CARRY		5
+#define SNARK_MAX_CARRY			15
+#define HORNET_MAX_CARRY		8
+#define M203_GRENADE_MAX_CARRY	10
+
+// the maximum amount of ammo each weapon's clip can hold
+#define WEAPON_NOCLIP			-1
+
+//#define CROWBAR_MAX_CLIP		WEAPON_NOCLIP
+#define GLOCK_MAX_CLIP			17
+#define PYTHON_MAX_CLIP			6
+#define MP5_MAX_CLIP			50
+#define MP5_DEFAULT_AMMO		25
+#define SHOTGUN_MAX_CLIP		8
+#define CROSSBOW_MAX_CLIP		5
+#define RPG_MAX_CLIP			1
+#define GAUSS_MAX_CLIP			WEAPON_NOCLIP
+#define EGON_MAX_CLIP			WEAPON_NOCLIP
+#define HORNETGUN_MAX_CLIP		WEAPON_NOCLIP
+#define HANDGRENADE_MAX_CLIP	WEAPON_NOCLIP
+#define SATCHEL_MAX_CLIP		WEAPON_NOCLIP
+#define TRIPMINE_MAX_CLIP		WEAPON_NOCLIP
+#define SNARK_MAX_CLIP			WEAPON_NOCLIP
+
+
+// the default amount of ammo that comes with each gun when it spawns
+#define GLOCK_DEFAULT_GIVE			17
+#define PYTHON_DEFAULT_GIVE			6
+#define MP5_DEFAULT_GIVE			25
+#define MP5_DEFAULT_AMMO			25
+#define MP5_M203_DEFAULT_GIVE		0
+#define SHOTGUN_DEFAULT_GIVE		12
+#define CROSSBOW_DEFAULT_GIVE		5
+#define RPG_DEFAULT_GIVE			1
+#define GAUSS_DEFAULT_GIVE			20
+#define EGON_DEFAULT_GIVE			20
+#define HANDGRENADE_DEFAULT_GIVE	5
+#define SATCHEL_DEFAULT_GIVE		1
+#define TRIPMINE_DEFAULT_GIVE		1
+#define SNARK_DEFAULT_GIVE			5
+#define HIVEHAND_DEFAULT_GIVE		8
+
+// The amount of ammo given to a player by an ammo item.
+#define AMMO_URANIUMBOX_GIVE	20
+#define AMMO_GLOCKCLIP_GIVE		GLOCK_MAX_CLIP
+#define AMMO_357BOX_GIVE		PYTHON_MAX_CLIP
+#define AMMO_MP5CLIP_GIVE		MP5_MAX_CLIP
+#define AMMO_CHAINBOX_GIVE		200
+#define AMMO_M203BOX_GIVE		2
+#define AMMO_BUCKSHOTBOX_GIVE	12
+#define AMMO_CROSSBOWCLIP_GIVE	CROSSBOW_MAX_CLIP
+#define AMMO_RPGCLIP_GIVE		RPG_MAX_CLIP
+#define AMMO_URANIUMBOX_GIVE	20
+#define AMMO_SNARKBOX_GIVE		5
+
+// bullet types
+typedef	enum
+{
+	BULLET_NONE = 0,
+	BULLET_PLAYER_9MM, // glock
+	BULLET_PLAYER_MP5, // mp5
+	BULLET_PLAYER_357, // python
+	BULLET_PLAYER_BUCKSHOT, // shotgun
+	BULLET_PLAYER_CROWBAR, // crowbar swipe
+
+	BULLET_MONSTER_9MM,
+	BULLET_MONSTER_MP5,
+	BULLET_MONSTER_12MM,
+} Bullet;
+
+
+#define ITEM_FLAG_SELECTONEMPTY		1
+#define ITEM_FLAG_NOAUTORELOAD		2
+#define ITEM_FLAG_NOAUTOSWITCHEMPTY	4
+#define ITEM_FLAG_LIMITINWORLD		8
+#define ITEM_FLAG_EXHAUSTIBLE		16 // A player can totally exhaust their ammo supply and lose this weapon
+
+#define WEAPON_IS_ONTARGET 0x40
+
+typedef struct
+{
+	int		iSlot;
+	int		iPosition;
+	const char	*pszAmmo1;	// ammo 1 type
+	int		iMaxAmmo1;		// max ammo 1
+	const char	*pszAmmo2;	// ammo 2 type
+	int		iMaxAmmo2;		// max ammo 2
+	const char	*pszName;
+	int		iMaxClip;
+	int		iId;
+	int		iFlags;
+	int		iWeight;// this value used to determine this weapon's importance in autoselection.
+} ItemInfo;
+
+typedef struct
+{
+	const char *pszName;
+	int iId;
+} AmmoInfo;
+
+// Items that the player has in their inventory that they can use
+class CBasePlayerItem : public CBaseAnimating
+{
+public:
+	virtual void SetObjectCollisionBox( void );
+
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	virtual int AddToPlayer( CBasePlayer *pPlayer );	// return TRUE if the item you want the item added to the player inventory
+	virtual int AddDuplicate( CBasePlayerItem *pItem ) { return FALSE; }	// return TRUE if you want your duplicate removed from world
+	void EXPORT DestroyItem( void );
+	void EXPORT DefaultTouch( CBaseEntity *pOther );	// default weapon touch
+	void EXPORT FallThink ( void );// when an item is first spawned, this think is run to determine when the object has hit the ground.
+	void EXPORT Materialize( void );// make a weapon visible and tangible
+	void EXPORT AttemptToMaterialize( void );  // the weapon desires to become visible and tangible, if the game rules allow for it
+	CBaseEntity* Respawn ( void );// copy a weapon
+	void FallInit( void );
+	void CheckRespawn( void );
+	virtual int GetItemInfo(ItemInfo *p) { return 0; };	// returns 0 if struct not filled out
+	virtual BOOL CanDeploy( void ) { return TRUE; };
+	virtual BOOL Deploy( )								// returns is deploy was successful
+		 { return TRUE; };
+
+	virtual BOOL CanHolster( void ) { return TRUE; };// can this weapon be put away right now?
+	virtual void Holster( int skiplocal = 0 );
+	virtual void UpdateItemInfo( void ) { return; };
+
+	virtual void ItemPreFrame( void )	{ return; }		// called each frame by the player PreThink
+	virtual void ItemPostFrame( void ) { return; }		// called each frame by the player PostThink
+
+	virtual void Drop( void );
+	virtual void Kill( void );
+	virtual void AttachToPlayer ( CBasePlayer *pPlayer );
+
+	virtual int PrimaryAmmoIndex() { return -1; };
+	virtual int SecondaryAmmoIndex() { return -1; };
+
+	virtual int UpdateClientData( CBasePlayer *pPlayer ) { return 0; }
+
+	virtual CBasePlayerItem *GetWeaponPtr( void ) { return NULL; };
+
+	static ItemInfo ItemInfoArray[ MAX_WEAPONS ];
+	static AmmoInfo AmmoInfoArray[ MAX_AMMO_SLOTS ];
+
+	CBasePlayer	*m_pPlayer;
+	CBasePlayerItem *m_pNext;
+	int		m_iId;												// WEAPON_???
+
+	virtual int iItemSlot( void ) { return 0; }			// return 0 to MAX_ITEMS_SLOTS, used in hud
+
+	int			iItemPosition( void ) { return ItemInfoArray[ m_iId ].iPosition; }
+	const char	*pszAmmo1( void )	{ return ItemInfoArray[ m_iId ].pszAmmo1; }
+	int			iMaxAmmo1( void )	{ return ItemInfoArray[ m_iId ].iMaxAmmo1; }
+	const char	*pszAmmo2( void )	{ return ItemInfoArray[ m_iId ].pszAmmo2; }
+	int			iMaxAmmo2( void )	{ return ItemInfoArray[ m_iId ].iMaxAmmo2; }
+	const char	*pszName( void )	{ return ItemInfoArray[ m_iId ].pszName; }
+	int			iMaxClip( void )	{ return ItemInfoArray[ m_iId ].iMaxClip; }
+	int			iWeight( void )		{ return ItemInfoArray[ m_iId ].iWeight; }
+	int			iFlags( void )		{ return ItemInfoArray[ m_iId ].iFlags; }
+
+	// int		m_iIdPrimary;										// Unique Id for primary ammo
+	// int		m_iIdSecondary;										// Unique Id for secondary ammo
+};
+
+
+// inventory items that 
+class CBasePlayerWeapon : public CBasePlayerItem
+{
+public:
+	virtual int		Save( CSave &save );
+	virtual int		Restore( CRestore &restore );
+	
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	// generic weapon versions of CBasePlayerItem calls
+	virtual int AddToPlayer( CBasePlayer *pPlayer );
+	virtual int AddDuplicate( CBasePlayerItem *pItem );
+
+	virtual int ExtractAmmo( CBasePlayerWeapon *pWeapon ); //{ return TRUE; };			// Return TRUE if you can add ammo to yourself when picked up
+	virtual int ExtractClipAmmo( CBasePlayerWeapon *pWeapon );// { return TRUE; };			// Return TRUE if you can add ammo to yourself when picked up
+
+	virtual int AddWeapon( void ) { ExtractAmmo( this ); return TRUE; };	// Return TRUE if you want to add yourself to the player
+
+	// generic "shared" ammo handlers
+	BOOL AddPrimaryAmmo( int iCount, char *szName, int iMaxClip, int iMaxCarry );
+	BOOL AddSecondaryAmmo( int iCount, char *szName, int iMaxCarry );
+
+	virtual void UpdateItemInfo( void ) {};	// updates HUD state
+
+	int m_iPlayEmptySound;
+	int m_fFireOnEmpty;		// True when the gun is empty and the player is still holding down the
+							// attack key(s)
+	virtual BOOL PlayEmptySound( void );
+	virtual void ResetEmptySound( void );
+
+	virtual void SendWeaponAnim( int iAnim, int skiplocal = 1, int body = 0 );  // skiplocal is 1 if client is predicting weapon animations
+
+	virtual BOOL CanDeploy( void );
+	virtual BOOL IsUseable( void );
+	BOOL DefaultDeploy( char *szViewModel, char *szWeaponModel, int iAnim, char *szAnimExt, int skiplocal = 0, int body = 0 );
+	int DefaultReload( int iClipSize, int iAnim, float fDelay, int body = 0 );
+
+	virtual void ItemPostFrame( void );	// called each frame by the player PostThink
+	// called by CBasePlayerWeapons ItemPostFrame()
+	virtual void PrimaryAttack( void ) { return; }				// do "+ATTACK"
+	virtual void SecondaryAttack( void ) { return; }			// do "+ATTACK2"
+	virtual void Reload( void ) { return; }						// do "+RELOAD"
+	virtual void WeaponIdle( void ) { return; }					// called when no buttons pressed
+	virtual int UpdateClientData( CBasePlayer *pPlayer );		// sends hud info to client dll, if things have changed
+	virtual void RetireWeapon( void );
+	virtual BOOL ShouldWeaponIdle( void ) {return FALSE; };
+	virtual void Holster( int skiplocal = 0 );
+	virtual BOOL UseDecrement( void ) { return FALSE; };
+	
+	int	PrimaryAmmoIndex(); 
+	int	SecondaryAmmoIndex(); 
+
+	void PrintState( void );
+
+	virtual CBasePlayerItem *GetWeaponPtr( void ) { return (CBasePlayerItem *)this; };
+
+	float m_flPumpTime;
+	int		m_fInSpecialReload;									// Are we in the middle of a reload for the shotguns
+	float	m_flNextPrimaryAttack;								// soonest time ItemPostFrame will call PrimaryAttack
+	float	m_flNextSecondaryAttack;							// soonest time ItemPostFrame will call SecondaryAttack
+	float	m_flTimeWeaponIdle;									// soonest time ItemPostFrame will call WeaponIdle
+	int		m_iPrimaryAmmoType;									// "primary" ammo index into players m_rgAmmo[]
+	int		m_iSecondaryAmmoType;								// "secondary" ammo index into players m_rgAmmo[]
+	int		m_iClip;											// number of shots left in the primary weapon clip, -1 it not used
+	int		m_iClientClip;										// the last version of m_iClip sent to hud dll
+	int		m_iClientWeaponState;								// the last version of the weapon state sent to hud dll (is current weapon, is on target)
+	int		m_fInReload;										// Are we in the middle of a reload;
+
+	int		m_iDefaultAmmo;// how much ammo you get when you pick up this weapon as placed by a level designer.
+
+};
+
+
+class CBasePlayerAmmo : public CBaseEntity
+{
+public:
+	virtual void Spawn( void );
+	void EXPORT DefaultTouch( CBaseEntity *pOther ); // default weapon touch
+	virtual BOOL AddAmmo( CBaseEntity *pOther ) { return TRUE; };
+
+	CBaseEntity* Respawn( void );
+	void EXPORT Materialize( void );
+};
+
+
+extern DLL_GLOBAL	short	g_sModelIndexLaser;// holds the index for the laser beam
+extern DLL_GLOBAL	const char *g_pModelNameLaser;
+
+extern DLL_GLOBAL	short	g_sModelIndexLaserDot;// holds the index for the laser beam dot
+extern DLL_GLOBAL	short	g_sModelIndexFireball;// holds the index for the fireball
+extern DLL_GLOBAL	short	g_sModelIndexSmoke;// holds the index for the smoke cloud
+extern DLL_GLOBAL	short	g_sModelIndexWExplosion;// holds the index for the underwater explosion
+extern DLL_GLOBAL	short	g_sModelIndexBubbles;// holds the index for the bubbles model
+extern DLL_GLOBAL	short	g_sModelIndexBloodDrop;// holds the sprite index for blood drops
+extern DLL_GLOBAL	short	g_sModelIndexBloodSpray;// holds the sprite index for blood spray (bigger)
+
+extern void ClearMultiDamage(void);
+extern void ApplyMultiDamage(entvars_t* pevInflictor, entvars_t* pevAttacker );
+extern void AddMultiDamage( entvars_t *pevInflictor, CBaseEntity *pEntity, float flDamage, int bitsDamageType);
+
+extern void DecalGunshot( TraceResult *pTrace, int iBulletType );
+extern void SpawnBlood(Vector vecSpot, int bloodColor, float flDamage);
+extern int DamageDecal( CBaseEntity *pEntity, int bitsDamageType );
+extern void RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, float flRadius, int iClassIgnore, int bitsDamageType );
+
+typedef struct 
+{
+	CBaseEntity		*pEntity;
+	float			amount;
+	int				type;
+} MULTIDAMAGE;
+
+extern MULTIDAMAGE gMultiDamage;
+
+
+#define LOUD_GUN_VOLUME			1000
+#define NORMAL_GUN_VOLUME		600
+#define QUIET_GUN_VOLUME		200
+
+#define	BRIGHT_GUN_FLASH		512
+#define NORMAL_GUN_FLASH		256
+#define	DIM_GUN_FLASH			128
+
+#define BIG_EXPLOSION_VOLUME	2048
+#define NORMAL_EXPLOSION_VOLUME	1024
+#define SMALL_EXPLOSION_VOLUME	512
+
+#define	WEAPON_ACTIVITY_VOLUME	64
+
+#define VECTOR_CONE_1DEGREES	Vector( 0.00873, 0.00873, 0.00873 )
+#define VECTOR_CONE_2DEGREES	Vector( 0.01745, 0.01745, 0.01745 )
+#define VECTOR_CONE_3DEGREES	Vector( 0.02618, 0.02618, 0.02618 )
+#define VECTOR_CONE_4DEGREES	Vector( 0.03490, 0.03490, 0.03490 )
+#define VECTOR_CONE_5DEGREES	Vector( 0.04362, 0.04362, 0.04362 )
+#define VECTOR_CONE_6DEGREES	Vector( 0.05234, 0.05234, 0.05234 )
+#define VECTOR_CONE_7DEGREES	Vector( 0.06105, 0.06105, 0.06105 )
+#define VECTOR_CONE_8DEGREES	Vector( 0.06976, 0.06976, 0.06976 )
+#define VECTOR_CONE_9DEGREES	Vector( 0.07846, 0.07846, 0.07846 )
+#define VECTOR_CONE_10DEGREES	Vector( 0.08716, 0.08716, 0.08716 )
+#define VECTOR_CONE_15DEGREES	Vector( 0.13053, 0.13053, 0.13053 )
+#define VECTOR_CONE_20DEGREES	Vector( 0.17365, 0.17365, 0.17365 )
+
+//=========================================================
+// CWeaponBox - a single entity that can store weapons
+// and ammo. 
+//=========================================================
+class CWeaponBox : public CBaseEntity
+{
+	void Precache( void );
+	void Spawn( void );
+	void Touch( CBaseEntity *pOther );
+	void KeyValue( KeyValueData *pkvd );
+	BOOL IsEmpty( void );
+	int  GiveAmmo( int iCount, char *szName, int iMax, int *pIndex = NULL );
+	void SetObjectCollisionBox( void );
+
+public:
+	void EXPORT Kill ( void );
+	int		Save( CSave &save );
+	int		Restore( CRestore &restore );
+	static	TYPEDESCRIPTION m_SaveData[];
+
+	BOOL HasWeapon( CBasePlayerItem *pCheckItem );
+	BOOL PackWeapon( CBasePlayerItem *pWeapon );
+	BOOL PackAmmo( int iszName, int iCount );
+	
+	CBasePlayerItem	*m_rgpPlayerItems[MAX_ITEM_TYPES];// one slot for each 
+
+	int m_rgiszAmmo[MAX_AMMO_SLOTS];// ammo names
+	int	m_rgAmmo[MAX_AMMO_SLOTS];// ammo quantities
+
+	int m_cAmmoTypes;// how many ammo types packed into this box (if packed by a level designer)
+};
+
+#ifdef CLIENT_DLL
+bool bIsMultiplayer ( void );
+void LoadVModel ( char *szViewModel, CBasePlayer *m_pPlayer );
+#endif
+
+class CGlock : public CBasePlayerWeapon
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 2; }
+	int GetItemInfo(ItemInfo *p);
+
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+	void GlockFire( float flSpread, float flCycleTime, BOOL fUseAutoAim );
+	BOOL Deploy( void );
+	void Reload( void );
+	void WeaponIdle( void );
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+
+private:
+	int m_iShell;
+	
+
+	unsigned short m_usFireGlock1;
+	unsigned short m_usFireGlock2;
+};
+
+
+class CCrowbar : public CBasePlayerWeapon
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 1; }
+	void EXPORT SwingAgain( void );
+	void EXPORT Smack( void );
+	int GetItemInfo(ItemInfo *p);
+
+	void PrimaryAttack( void );
+	int Swing( int fFirst );
+	BOOL Deploy( void );
+	void Holster( int skiplocal = 0 );
+	int m_iSwing;
+	TraceResult m_trHit;
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+private:
+	unsigned short m_usCrowbar;
+};
+
+class CPython : public CBasePlayerWeapon
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 2; }
+	int GetItemInfo(ItemInfo *p);
+	int AddToPlayer( CBasePlayer *pPlayer );
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+	BOOL Deploy( void );
+	void Holster( int skiplocal = 0 );
+	void Reload( void );
+	void WeaponIdle( void );
+	float m_flSoundDelay;
+
+	BOOL m_fInZoom;// don't save this. 
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+
+private:
+	unsigned short m_usFirePython;
+};
+
+class CMP5 : public CBasePlayerWeapon
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 3; }
+	int GetItemInfo(ItemInfo *p);
+	int AddToPlayer( CBasePlayer *pPlayer );
+
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+	int SecondaryAmmoIndex( void );
+	BOOL Deploy( void );
+	void Reload( void );
+	void WeaponIdle( void );
+	float m_flNextAnimTime;
+	int m_iShell;
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+
+private:
+	unsigned short m_usMP5;
+	unsigned short m_usMP52;
+};
+
+class CCrossbow : public CBasePlayerWeapon
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( ) { return 3; }
+	int GetItemInfo(ItemInfo *p);
+
+	void FireBolt( void );
+	void FireSniperBolt( void );
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+	int AddToPlayer( CBasePlayer *pPlayer );
+	BOOL Deploy( );
+	void Holster( int skiplocal = 0 );
+	void Reload( void );
+	void WeaponIdle( void );
+
+	int m_fInZoom; // don't save this
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+
+private:
+	unsigned short m_usCrossbow;
+	unsigned short m_usCrossbow2;
+};
+
+class CShotgun : public CBasePlayerWeapon
+{
+public:
+
+#ifndef CLIENT_DLL
+	int		Save( CSave &save );
+	int		Restore( CRestore &restore );
+	static	TYPEDESCRIPTION m_SaveData[];
+#endif
+
+
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( ) { return 3; }
+	int GetItemInfo(ItemInfo *p);
+	int AddToPlayer( CBasePlayer *pPlayer );
+
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+	BOOL Deploy( );
+	void Reload( void );
+	void WeaponIdle( void );
+	int m_fInReload;
+	float m_flNextReload;
+	int m_iShell;
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+
+private:
+	unsigned short m_usDoubleFire;
+	unsigned short m_usSingleFire;
+};
+
+class CLaserSpot : public CBaseEntity
+{
+	void Spawn( void );
+	void Precache( void );
+
+	int	ObjectCaps( void ) { return FCAP_DONT_SAVE; }
+
+public:
+	void Suspend( float flSuspendTime );
+	void EXPORT Revive( void );
+	
+	static CLaserSpot *CreateSpot( void );
+};
+
+class CRpg : public CBasePlayerWeapon
+{
+public:
+
+#ifndef CLIENT_DLL
+	int		Save( CSave &save );
+	int		Restore( CRestore &restore );
+	static	TYPEDESCRIPTION m_SaveData[];
+#endif
+
+	void Spawn( void );
+	void Precache( void );
+	void Reload( void );
+	int iItemSlot( void ) { return 4; }
+	int GetItemInfo(ItemInfo *p);
+	int AddToPlayer( CBasePlayer *pPlayer );
+
+	BOOL Deploy( void );
+	BOOL CanHolster( void );
+	void Holster( int skiplocal = 0 );
+
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+	void WeaponIdle( void );
+
+	void UpdateSpot( void );
+	BOOL ShouldWeaponIdle( void ) { return TRUE; };
+
+	CLaserSpot *m_pSpot;
+	int m_fSpotActive;
+	int m_cActiveRockets;// how many missiles in flight from this launcher right now?
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+
+private:
+	unsigned short m_usRpg;
+
+};
+
+class CRpgRocket : public CGrenade
+{
+public:
+	int		Save( CSave &save );
+	int		Restore( CRestore &restore );
+	static	TYPEDESCRIPTION m_SaveData[];
+	void Spawn( void );
+	void Precache( void );
+	void EXPORT FollowThink( void );
+	void EXPORT IgniteThink( void );
+	void EXPORT RocketTouch( CBaseEntity *pOther );
+	static CRpgRocket *CreateRpgRocket( Vector vecOrigin, Vector vecAngles, CBaseEntity *pOwner, CRpg *pLauncher );
+
+	int m_iTrail;
+	float m_flIgniteTime;
+	CRpg *m_pLauncher;// pointer back to the launcher that fired me. 
+};
+
+class CGauss : public CBasePlayerWeapon
+{
+public:
+
+#ifndef CLIENT_DLL
+	int		Save( CSave &save );
+	int		Restore( CRestore &restore );
+	static	TYPEDESCRIPTION m_SaveData[];
+#endif
+
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 4; }
+	int GetItemInfo(ItemInfo *p);
+	int AddToPlayer( CBasePlayer *pPlayer );
+
+	BOOL Deploy( void );
+	void Holster( int skiplocal = 0  );
+
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+	void WeaponIdle( void );
+	
+	void StartFire( void );
+	void Fire( Vector vecOrigSrc, Vector vecDirShooting, float flDamage );
+	float GetFullChargeTime( void );
+	int m_iBalls;
+	int m_iGlow;
+	int m_iBeam;
+	int m_iSoundState; // don't save this
+
+	// was this weapon just fired primary or secondary?
+	// we need to know so we can pick the right set of effects. 
+	BOOL m_fPrimaryFire;
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+
+private:
+	unsigned short m_usGaussFire;
+	unsigned short m_usGaussSpin;
+};
+
+class CEgon : public CBasePlayerWeapon
+{
+public:
+#ifndef CLIENT_DLL
+	int		Save( CSave &save );
+	int		Restore( CRestore &restore );
+	static	TYPEDESCRIPTION m_SaveData[];
+#endif
+
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 4; }
+	int GetItemInfo(ItemInfo *p);
+	int AddToPlayer( CBasePlayer *pPlayer );
+
+	BOOL Deploy( void );
+	void Holster( int skiplocal = 0 );
+
+	void UpdateEffect( const Vector &startPoint, const Vector &endPoint, float timeBlend );
+
+	void CreateEffect ( void );
+	void DestroyEffect ( void );
+
+	void EndAttack( void );
+	void Attack( void );
+	void PrimaryAttack( void );
+	void WeaponIdle( void );
+
+	float m_flAmmoUseTime;// since we use < 1 point of ammo per update, we subtract ammo on a timer.
+
+	float GetPulseInterval( void );
+	float GetDischargeInterval( void );
+
+	void Fire( const Vector &vecOrigSrc, const Vector &vecDir );
+
+	BOOL HasAmmo( void );
+
+	void UseAmmo( int count );
+	
+	enum EGON_FIREMODE { FIRE_NARROW, FIRE_WIDE};
+
+	CBeam				*m_pBeam;
+	CBeam				*m_pNoise;
+	CSprite				*m_pSprite;
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+
+	unsigned short m_usEgonStop;
+
+private:
+	float				m_shootTime;
+	EGON_FIREMODE		m_fireMode;
+	float				m_shakeTime;
+	BOOL				m_deployed;
+
+	unsigned short m_usEgonFire;
+};
+
+class CHgun : public CBasePlayerWeapon
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 4; }
+	int GetItemInfo(ItemInfo *p);
+	int AddToPlayer( CBasePlayer *pPlayer );
+
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+	BOOL Deploy( void );
+	BOOL IsUseable( void );
+	void Holster( int skiplocal = 0 );
+	void Reload( void );
+	void WeaponIdle( void );
+	float m_flNextAnimTime;
+
+	float m_flRechargeTime;
+	
+	int m_iFirePhase;// don't save me.
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+private:
+	unsigned short m_usHornetFire;
+};
+
+
+
+class CHandGrenade : public CBasePlayerWeapon
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 5; }
+	int GetItemInfo(ItemInfo *p);
+
+	void PrimaryAttack( void );
+	BOOL Deploy( void );
+	BOOL CanHolster( void );
+	void Holster( int skiplocal = 0 );
+	void WeaponIdle( void );
+	
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+};
+
+class CSatchel : public CBasePlayerWeapon
+{
+public:
+
+#ifndef CLIENT_DLL
+	int		Save( CSave &save );
+	int		Restore( CRestore &restore );
+	static	TYPEDESCRIPTION m_SaveData[];
+#endif
+
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 5; }
+	int GetItemInfo(ItemInfo *p);
+	int AddToPlayer( CBasePlayer *pPlayer );
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+	int AddDuplicate( CBasePlayerItem *pOriginal );
+	BOOL CanDeploy( void );
+	BOOL Deploy( void );
+	BOOL IsUseable( void );
+	
+	void Holster( int skiplocal = 0 );
+	void WeaponIdle( void );
+	void Throw( void );
+	
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+};
+
+
+class CTripmine : public CBasePlayerWeapon
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 5; }
+	int GetItemInfo(ItemInfo *p);
+	void SetObjectCollisionBox( void )
+	{
+		//!!!BUGBUG - fix the model!
+		pev->absmin = pev->origin + Vector(-16, -16, -5);
+		pev->absmax = pev->origin + Vector(16, 16, 28); 
+	}
+
+	void PrimaryAttack( void );
+	BOOL Deploy( void );
+	void Holster( int skiplocal = 0 );
+	void WeaponIdle( void );
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+
+private:
+	unsigned short m_usTripFire;
+
+};
+
+class CSqueak : public CBasePlayerWeapon
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int iItemSlot( void ) { return 5; }
+	int GetItemInfo(ItemInfo *p);
+
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+	BOOL Deploy( void );
+	void Holster( int skiplocal = 0 );
+	void WeaponIdle( void );
+	int m_fJustThrown;
+
+	virtual BOOL UseDecrement( void )
+	{ 
+#if defined( CLIENT_WEAPONS )
+		return TRUE;
+#else
+		return FALSE;
+#endif
+	}
+
+private:
+	unsigned short m_usSnarkFire;
+};
+
+
+#endif // WEAPONS_H
diff --git a/sdk/hlsdk/engine/Sequence.h b/sdk/hlsdk/engine/Sequence.h
new file mode 100644
index 0000000..6253018
--- /dev/null
+++ b/sdk/hlsdk/engine/Sequence.h
@@ -0,0 +1,201 @@
+//---------------------------------------------------------------------------
+// 
+//		S c r i p t e d   S e q u e n c e s
+// 
+//---------------------------------------------------------------------------
+#ifndef _INCLUDE_SEQUENCE_H_
+#define _INCLUDE_SEQUENCE_H_
+
+
+#ifndef _DEF_BYTE_
+typedef unsigned char byte;
+#endif
+
+//---------------------------------------------------------------------------
+// client_textmessage_t
+//---------------------------------------------------------------------------
+typedef struct client_textmessage_s
+{
+	int		effect;
+	byte	r1, g1, b1, a1;		// 2 colors for effects
+	byte	r2, g2, b2, a2;
+	float	x;
+	float	y;
+	float	fadein;
+	float	fadeout;
+	float	holdtime;
+	float	fxtime;
+	const char *pName;
+	const char *pMessage;
+} client_textmessage_t;
+
+
+//--------------------------------------------------------------------------
+// sequenceDefaultBits_e
+//	
+// Enumerated list of possible modifiers for a command.  This enumeration
+// is used in a bitarray controlling what modifiers are specified for a command.
+//---------------------------------------------------------------------------
+enum sequenceModifierBits
+{
+	SEQUENCE_MODIFIER_EFFECT_BIT		= (1 << 1),
+	SEQUENCE_MODIFIER_POSITION_BIT		= (1 << 2),
+	SEQUENCE_MODIFIER_COLOR_BIT			= (1 << 3),
+	SEQUENCE_MODIFIER_COLOR2_BIT		= (1 << 4),
+	SEQUENCE_MODIFIER_FADEIN_BIT		= (1 << 5),
+	SEQUENCE_MODIFIER_FADEOUT_BIT		= (1 << 6),
+	SEQUENCE_MODIFIER_HOLDTIME_BIT		= (1 << 7),
+	SEQUENCE_MODIFIER_FXTIME_BIT		= (1 << 8),
+	SEQUENCE_MODIFIER_SPEAKER_BIT		= (1 << 9),
+	SEQUENCE_MODIFIER_LISTENER_BIT		= (1 << 10),
+	SEQUENCE_MODIFIER_TEXTCHANNEL_BIT	= (1 << 11),
+};
+typedef enum sequenceModifierBits sequenceModifierBits_e ;
+
+
+//---------------------------------------------------------------------------
+// sequenceCommandEnum_e
+// 
+// Enumerated sequence command types.
+//---------------------------------------------------------------------------
+enum sequenceCommandEnum_
+{
+	SEQUENCE_COMMAND_ERROR = -1,
+	SEQUENCE_COMMAND_PAUSE = 0,
+	SEQUENCE_COMMAND_FIRETARGETS,
+	SEQUENCE_COMMAND_KILLTARGETS,
+	SEQUENCE_COMMAND_TEXT,
+	SEQUENCE_COMMAND_SOUND,
+	SEQUENCE_COMMAND_GOSUB,
+	SEQUENCE_COMMAND_SENTENCE,
+	SEQUENCE_COMMAND_REPEAT,
+	SEQUENCE_COMMAND_SETDEFAULTS,
+	SEQUENCE_COMMAND_MODIFIER,
+	SEQUENCE_COMMAND_POSTMODIFIER,
+	SEQUENCE_COMMAND_NOOP,
+
+	SEQUENCE_MODIFIER_EFFECT,
+	SEQUENCE_MODIFIER_POSITION,
+	SEQUENCE_MODIFIER_COLOR,
+	SEQUENCE_MODIFIER_COLOR2,
+	SEQUENCE_MODIFIER_FADEIN,
+	SEQUENCE_MODIFIER_FADEOUT,
+	SEQUENCE_MODIFIER_HOLDTIME,
+	SEQUENCE_MODIFIER_FXTIME,
+	SEQUENCE_MODIFIER_SPEAKER,
+	SEQUENCE_MODIFIER_LISTENER,
+	SEQUENCE_MODIFIER_TEXTCHANNEL,
+};
+typedef enum sequenceCommandEnum_ sequenceCommandEnum_e;
+
+
+//---------------------------------------------------------------------------
+// sequenceCommandType_e
+// 
+// Typeerated sequence command types.
+//---------------------------------------------------------------------------
+enum sequenceCommandType_
+{
+	SEQUENCE_TYPE_COMMAND,
+	SEQUENCE_TYPE_MODIFIER,
+};
+typedef enum sequenceCommandType_ sequenceCommandType_e;
+
+
+//---------------------------------------------------------------------------
+// sequenceCommandMapping_s
+// 
+// A mapping of a command enumerated-value to its name.
+//---------------------------------------------------------------------------
+typedef struct sequenceCommandMapping_ sequenceCommandMapping_s;
+struct sequenceCommandMapping_
+{
+	sequenceCommandEnum_e	commandEnum;
+	const char*				commandName;
+	sequenceCommandType_e	commandType;
+};
+
+
+//---------------------------------------------------------------------------
+// sequenceCommandLine_s
+// 
+// Structure representing a single command (usually 1 line) from a
+//	.SEQ file entry.
+//---------------------------------------------------------------------------
+typedef struct sequenceCommandLine_ sequenceCommandLine_s;
+struct sequenceCommandLine_
+{
+	int						commandType;		// Specifies the type of command
+	client_textmessage_t	clientMessage;		// Text HUD message struct
+	char*					speakerName;		// Targetname of speaking entity
+	char*					listenerName;		// Targetname of entity being spoken to
+	char*					soundFileName;		// Name of sound file to play
+	char*					sentenceName;		// Name of sentences.txt to play
+	char*					fireTargetNames;	// List of targetnames to fire
+	char*					killTargetNames;	// List of targetnames to remove
+	float					delay;				// Seconds 'till next command
+	int						repeatCount;		// If nonzero, reset execution pointer to top of block (N times, -1 = infinite)
+	int						textChannel;		// Display channel on which text message is sent
+	int						modifierBitField;	// Bit field to specify what clientmessage fields are valid
+	sequenceCommandLine_s*	nextCommandLine;	// Next command (linked list)
+};
+
+
+//---------------------------------------------------------------------------
+// sequenceEntry_s
+// 
+// Structure representing a single command (usually 1 line) from a
+//	.SEQ file entry.
+//---------------------------------------------------------------------------
+typedef struct sequenceEntry_ sequenceEntry_s;
+struct sequenceEntry_
+{
+	char*					fileName;		// Name of sequence file without .SEQ extension
+	char*					entryName;		// Name of entry label in file
+	sequenceCommandLine_s*	firstCommand;	// Linked list of commands in entry
+	sequenceEntry_s*		nextEntry;		// Next loaded entry
+	qboolean				isGlobal;		// Is entry retained over level transitions?
+};
+
+
+
+//---------------------------------------------------------------------------
+// sentenceEntry_s
+// Structure representing a single sentence of a group from a .SEQ
+// file entry.  Sentences are identical to entries in sentences.txt, but
+// can be unique per level and are loaded/unloaded with the level.
+//---------------------------------------------------------------------------
+typedef struct sentenceEntry_ sentenceEntry_s;
+struct sentenceEntry_
+{
+	char*					data;			// sentence data (ie "We have hostiles" )
+	sentenceEntry_s*		nextEntry;		// Next loaded entry
+	qboolean				isGlobal;		// Is entry retained over level transitions?
+	unsigned int			index;			// this entry's position in the file.
+};
+
+//--------------------------------------------------------------------------
+// sentenceGroupEntry_s
+// Structure representing a group of sentences found in a .SEQ file.
+// A sentence group is defined by all sentences with the same name, ignoring
+// the number at the end of the sentence name.  Groups enable a sentence
+// to be picked at random across a group.
+//--------------------------------------------------------------------------
+typedef struct sentenceGroupEntry_ sentenceGroupEntry_s;
+struct sentenceGroupEntry_
+{
+	char*					groupName;		// name of the group (ie CT_ALERT )
+	unsigned int			numSentences;	// number of sentences in group
+	sentenceEntry_s*		firstSentence;	// head of linked list of sentences in group
+	sentenceGroupEntry_s*	nextEntry;		// next loaded group
+};
+
+//---------------------------------------------------------------------------
+// Function declarations
+//---------------------------------------------------------------------------
+sequenceEntry_s* SequenceGet( const char* fileName, const char* entryName );
+void Sequence_ParseFile( const char* fileName, qboolean isGlobal );
+void Sequence_OnLevelLoad( const char* mapName );
+sentenceEntry_s* SequencePickSentence( const char *groupName, int pickMethod, int *picked );
+
+#endif /* _INCLUDE_SEQUENCE_H_ */
diff --git a/sdk/hlsdk/engine/anorms.h b/sdk/hlsdk/engine/anorms.h
new file mode 100644
index 0000000..d147aea
--- /dev/null
+++ b/sdk/hlsdk/engine/anorms.h
@@ -0,0 +1,177 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+
+{-0.525731, 0.000000, 0.850651}, 
+{-0.442863, 0.238856, 0.864188}, 
+{-0.295242, 0.000000, 0.955423}, 
+{-0.309017, 0.500000, 0.809017}, 
+{-0.162460, 0.262866, 0.951056}, 
+{0.000000, 0.000000, 1.000000}, 
+{0.000000, 0.850651, 0.525731}, 
+{-0.147621, 0.716567, 0.681718}, 
+{0.147621, 0.716567, 0.681718}, 
+{0.000000, 0.525731, 0.850651}, 
+{0.309017, 0.500000, 0.809017}, 
+{0.525731, 0.000000, 0.850651}, 
+{0.295242, 0.000000, 0.955423}, 
+{0.442863, 0.238856, 0.864188}, 
+{0.162460, 0.262866, 0.951056}, 
+{-0.681718, 0.147621, 0.716567}, 
+{-0.809017, 0.309017, 0.500000}, 
+{-0.587785, 0.425325, 0.688191}, 
+{-0.850651, 0.525731, 0.000000}, 
+{-0.864188, 0.442863, 0.238856}, 
+{-0.716567, 0.681718, 0.147621}, 
+{-0.688191, 0.587785, 0.425325}, 
+{-0.500000, 0.809017, 0.309017}, 
+{-0.238856, 0.864188, 0.442863}, 
+{-0.425325, 0.688191, 0.587785}, 
+{-0.716567, 0.681718, -0.147621}, 
+{-0.500000, 0.809017, -0.309017}, 
+{-0.525731, 0.850651, 0.000000}, 
+{0.000000, 0.850651, -0.525731}, 
+{-0.238856, 0.864188, -0.442863}, 
+{0.000000, 0.955423, -0.295242}, 
+{-0.262866, 0.951056, -0.162460}, 
+{0.000000, 1.000000, 0.000000}, 
+{0.000000, 0.955423, 0.295242}, 
+{-0.262866, 0.951056, 0.162460}, 
+{0.238856, 0.864188, 0.442863}, 
+{0.262866, 0.951056, 0.162460}, 
+{0.500000, 0.809017, 0.309017}, 
+{0.238856, 0.864188, -0.442863}, 
+{0.262866, 0.951056, -0.162460}, 
+{0.500000, 0.809017, -0.309017}, 
+{0.850651, 0.525731, 0.000000}, 
+{0.716567, 0.681718, 0.147621}, 
+{0.716567, 0.681718, -0.147621}, 
+{0.525731, 0.850651, 0.000000}, 
+{0.425325, 0.688191, 0.587785}, 
+{0.864188, 0.442863, 0.238856}, 
+{0.688191, 0.587785, 0.425325}, 
+{0.809017, 0.309017, 0.500000}, 
+{0.681718, 0.147621, 0.716567}, 
+{0.587785, 0.425325, 0.688191}, 
+{0.955423, 0.295242, 0.000000}, 
+{1.000000, 0.000000, 0.000000}, 
+{0.951056, 0.162460, 0.262866}, 
+{0.850651, -0.525731, 0.000000}, 
+{0.955423, -0.295242, 0.000000}, 
+{0.864188, -0.442863, 0.238856}, 
+{0.951056, -0.162460, 0.262866}, 
+{0.809017, -0.309017, 0.500000}, 
+{0.681718, -0.147621, 0.716567}, 
+{0.850651, 0.000000, 0.525731}, 
+{0.864188, 0.442863, -0.238856}, 
+{0.809017, 0.309017, -0.500000}, 
+{0.951056, 0.162460, -0.262866}, 
+{0.525731, 0.000000, -0.850651}, 
+{0.681718, 0.147621, -0.716567}, 
+{0.681718, -0.147621, -0.716567}, 
+{0.850651, 0.000000, -0.525731}, 
+{0.809017, -0.309017, -0.500000}, 
+{0.864188, -0.442863, -0.238856}, 
+{0.951056, -0.162460, -0.262866}, 
+{0.147621, 0.716567, -0.681718}, 
+{0.309017, 0.500000, -0.809017}, 
+{0.425325, 0.688191, -0.587785}, 
+{0.442863, 0.238856, -0.864188}, 
+{0.587785, 0.425325, -0.688191}, 
+{0.688191, 0.587785, -0.425325}, 
+{-0.147621, 0.716567, -0.681718}, 
+{-0.309017, 0.500000, -0.809017}, 
+{0.000000, 0.525731, -0.850651}, 
+{-0.525731, 0.000000, -0.850651}, 
+{-0.442863, 0.238856, -0.864188}, 
+{-0.295242, 0.000000, -0.955423}, 
+{-0.162460, 0.262866, -0.951056}, 
+{0.000000, 0.000000, -1.000000}, 
+{0.295242, 0.000000, -0.955423}, 
+{0.162460, 0.262866, -0.951056}, 
+{-0.442863, -0.238856, -0.864188}, 
+{-0.309017, -0.500000, -0.809017}, 
+{-0.162460, -0.262866, -0.951056}, 
+{0.000000, -0.850651, -0.525731}, 
+{-0.147621, -0.716567, -0.681718}, 
+{0.147621, -0.716567, -0.681718}, 
+{0.000000, -0.525731, -0.850651}, 
+{0.309017, -0.500000, -0.809017}, 
+{0.442863, -0.238856, -0.864188}, 
+{0.162460, -0.262866, -0.951056}, 
+{0.238856, -0.864188, -0.442863}, 
+{0.500000, -0.809017, -0.309017}, 
+{0.425325, -0.688191, -0.587785}, 
+{0.716567, -0.681718, -0.147621}, 
+{0.688191, -0.587785, -0.425325}, 
+{0.587785, -0.425325, -0.688191}, 
+{0.000000, -0.955423, -0.295242}, 
+{0.000000, -1.000000, 0.000000}, 
+{0.262866, -0.951056, -0.162460}, 
+{0.000000, -0.850651, 0.525731}, 
+{0.000000, -0.955423, 0.295242}, 
+{0.238856, -0.864188, 0.442863}, 
+{0.262866, -0.951056, 0.162460}, 
+{0.500000, -0.809017, 0.309017}, 
+{0.716567, -0.681718, 0.147621}, 
+{0.525731, -0.850651, 0.000000}, 
+{-0.238856, -0.864188, -0.442863}, 
+{-0.500000, -0.809017, -0.309017}, 
+{-0.262866, -0.951056, -0.162460}, 
+{-0.850651, -0.525731, 0.000000}, 
+{-0.716567, -0.681718, -0.147621}, 
+{-0.716567, -0.681718, 0.147621}, 
+{-0.525731, -0.850651, 0.000000}, 
+{-0.500000, -0.809017, 0.309017}, 
+{-0.238856, -0.864188, 0.442863}, 
+{-0.262866, -0.951056, 0.162460}, 
+{-0.864188, -0.442863, 0.238856}, 
+{-0.809017, -0.309017, 0.500000}, 
+{-0.688191, -0.587785, 0.425325}, 
+{-0.681718, -0.147621, 0.716567}, 
+{-0.442863, -0.238856, 0.864188}, 
+{-0.587785, -0.425325, 0.688191}, 
+{-0.309017, -0.500000, 0.809017}, 
+{-0.147621, -0.716567, 0.681718}, 
+{-0.425325, -0.688191, 0.587785}, 
+{-0.162460, -0.262866, 0.951056}, 
+{0.442863, -0.238856, 0.864188}, 
+{0.162460, -0.262866, 0.951056}, 
+{0.309017, -0.500000, 0.809017}, 
+{0.147621, -0.716567, 0.681718}, 
+{0.000000, -0.525731, 0.850651}, 
+{0.425325, -0.688191, 0.587785}, 
+{0.587785, -0.425325, 0.688191}, 
+{0.688191, -0.587785, 0.425325}, 
+{-0.955423, 0.295242, 0.000000}, 
+{-0.951056, 0.162460, 0.262866}, 
+{-1.000000, 0.000000, 0.000000}, 
+{-0.850651, 0.000000, 0.525731}, 
+{-0.955423, -0.295242, 0.000000}, 
+{-0.951056, -0.162460, 0.262866}, 
+{-0.864188, 0.442863, -0.238856}, 
+{-0.951056, 0.162460, -0.262866}, 
+{-0.809017, 0.309017, -0.500000}, 
+{-0.864188, -0.442863, -0.238856}, 
+{-0.951056, -0.162460, -0.262866}, 
+{-0.809017, -0.309017, -0.500000}, 
+{-0.681718, 0.147621, -0.716567}, 
+{-0.681718, -0.147621, -0.716567}, 
+{-0.850651, 0.000000, -0.525731}, 
+{-0.688191, 0.587785, -0.425325}, 
+{-0.587785, 0.425325, -0.688191}, 
+{-0.425325, 0.688191, -0.587785}, 
+{-0.425325, -0.688191, -0.587785}, 
+{-0.587785, -0.425325, -0.688191}, 
+{-0.688191, -0.587785, -0.425325}, 
diff --git a/sdk/hlsdk/engine/archtypes.h b/sdk/hlsdk/engine/archtypes.h
new file mode 100644
index 0000000..3315135
--- /dev/null
+++ b/sdk/hlsdk/engine/archtypes.h
@@ -0,0 +1,41 @@
+//
+// Word size dependent definitions
+// DAL 1/03
+//
+#ifndef ARCHTYPES_H
+#define ARCHTYPES_H
+
+#ifdef __x86_64__
+#define X64BITS
+#endif
+
+#if defined( _WIN32 ) && (! defined( __MINGW32__ ))
+
+typedef __int16 int16;
+typedef unsigned __int16 uint16;
+typedef __int32 int32;
+typedef unsigned __int32 uint32;
+typedef __int64 int64;
+typedef unsigned __int64 uint64;
+typedef __int32 intp;				// intp is an integer that can accomodate a pointer
+typedef unsigned __int32 uintp;		// (ie, sizeof(intp) >= sizeof(int) && sizeof(intp) >= sizeof(void *)
+
+#else /* _WIN32 */
+
+typedef short int16;
+typedef unsigned short uint16;
+typedef int int32;
+typedef unsigned int uint32;
+typedef long long int64;
+typedef unsigned long long uint64;
+#ifdef X64BITS
+typedef long long intp;
+typedef unsigned long long uintp;
+#else
+typedef int intp;
+typedef unsigned int uintp;
+#endif
+
+#endif /* else _WIN32 */
+
+#endif /* ARCHTYPES_H */
diff --git a/sdk/hlsdk/engine/cdll_int.h b/sdk/hlsdk/engine/cdll_int.h
new file mode 100644
index 0000000..18db1f7
--- /dev/null
+++ b/sdk/hlsdk/engine/cdll_int.h
@@ -0,0 +1,311 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+//
+//  cdll_int.h
+//
+// 4-23-98  
+// JOHN:  client dll interface declarations
+//
+
+#ifndef CDLL_INT_H
+#define CDLL_INT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "const.h"
+
+
+// this file is included by both the engine and the client-dll,
+// so make sure engine declarations aren't done twice
+
+typedef int HSPRITE;	// handle to a graphic
+
+#define SCRINFO_SCREENFLASH 1
+#define SCRINFO_STRETCHED	2
+
+typedef struct SCREENINFO_s
+{
+	int		iSize;
+	int		iWidth;
+	int		iHeight;
+	int		iFlags;
+	int		iCharHeight;
+	short	charWidths[256];
+} SCREENINFO;
+
+
+typedef struct client_data_s
+{
+	// fields that cannot be modified  (ie. have no effect if changed)
+	vec3_t origin;
+
+	// fields that can be changed by the cldll
+	vec3_t viewangles;
+	int		iWeaponBits;
+	float	fov;	// field of view
+} client_data_t;
+
+typedef struct client_sprite_s
+{
+	char szName[64];
+	char szSprite[64];
+	int hspr;
+	int iRes;
+	wrect_t rc;
+} client_sprite_t;
+
+typedef struct client_textmessage_s
+{
+	int		effect;
+	byte	r1, g1, b1, a1;		// 2 colors for effects
+	byte	r2, g2, b2, a2;
+	float	x;
+	float	y;
+	float	fadein;
+	float	fadeout;
+	float	holdtime;
+	float	fxtime;
+	const char *pName;
+	const char *pMessage;
+} client_textmessage_t;
+
+typedef struct hud_player_info_s
+{
+	char *name;
+	short ping;
+	byte thisplayer;  // TRUE if this is the calling player
+
+  // stuff that's unused at the moment,  but should be done
+	byte spectator;
+	byte packetloss;
+
+	char *model;
+	short topcolor;
+	short bottomcolor;
+
+} hud_player_info_t;
+
+
+typedef struct cl_enginefuncs_s
+{
+	// sprite handlers
+	HSPRITE						( *pfnSPR_Load )			( const char *szPicName );
+	int							( *pfnSPR_Frames )			( HSPRITE hPic );
+	int							( *pfnSPR_Height )			( HSPRITE hPic, int frame );
+	int							( *pfnSPR_Width )			( HSPRITE hPic, int frame );
+	void						( *pfnSPR_Set )				( HSPRITE hPic, int r, int g, int b );
+	void						( *pfnSPR_Draw )			( int frame, int x, int y, const wrect_t *prc );
+	void						( *pfnSPR_DrawHoles )		( int frame, int x, int y, const wrect_t *prc );
+	void						( *pfnSPR_DrawAdditive )	( int frame, int x, int y, const wrect_t *prc );
+	void						( *pfnSPR_EnableScissor )	( int x, int y, int width, int height );
+	void						( *pfnSPR_DisableScissor )	( void );
+	client_sprite_t				*( *pfnSPR_GetList )			( char *psz, int *piCount );
+
+	// screen handlers
+	void						( *pfnFillRGBA )			( int x, int y, int width, int height, int r, int g, int b, int a );
+	int							( *pfnGetScreenInfo ) 		( SCREENINFO *pscrinfo );
+	void						( *pfnSetCrosshair )		( HSPRITE hspr, wrect_t rc, int r, int g, int b );
+
+	// cvar handlers
+	struct cvar_s				*( *pfnRegisterVariable )	( char *szName, char *szValue, int flags );
+	float						( *pfnGetCvarFloat )		( char *szName );
+	char*						( *pfnGetCvarString )		( char *szName );
+
+	// command handlers
+	int							( *pfnAddCommand )			( char *cmd_name, void (*function)(void) );
+	int							( *pfnHookUserMsg )			( char *szMsgName, pfnUserMsgHook pfn );
+	int							( *pfnServerCmd )			( char *szCmdString );
+	int							( *pfnClientCmd )			( char *szCmdString );
+
+	void						( *pfnGetPlayerInfo )		( int ent_num, hud_player_info_t *pinfo );
+
+	// sound handlers
+	void						( *pfnPlaySoundByName )		( char *szSound, float volume );
+	void						( *pfnPlaySoundByIndex )	( int iSound, float volume );
+
+	// vector helpers
+	void						( *pfnAngleVectors )		( const float * vecAngles, float * forward, float * right, float * up );
+
+	// text message system
+	client_textmessage_t		*( *pfnTextMessageGet )		( const char *pName );
+	int							( *pfnDrawCharacter )		( int x, int y, int number, int r, int g, int b );
+	int							( *pfnDrawConsoleString )	( int x, int y, char *string );
+	void						( *pfnDrawSetTextColor )	( float r, float g, float b );
+	void						( *pfnDrawConsoleStringLen )(  const char *string, int *length, int *height );
+
+	void						( *pfnConsolePrint )		( const char *string );
+	void						( *pfnCenterPrint )			( const char *string );
+
+
+// Added for user input processing
+	int							( *GetWindowCenterX )		( void );
+	int							( *GetWindowCenterY )		( void );
+	void						( *GetViewAngles )			( float * );
+	void						( *SetViewAngles )			( float * );
+	int							( *GetMaxClients )			( void );
+	void						( *Cvar_SetValue )			( char *cvar, float value );
+
+	int       					(*Cmd_Argc)					(void);	
+	char						*( *Cmd_Argv )				( int arg );
+	void						( *Con_Printf )				( char *fmt, ... );
+	void						( *Con_DPrintf )			( char *fmt, ... );
+	void						( *Con_NPrintf )			( int pos, char *fmt, ... );
+	void						( *Con_NXPrintf )			( struct con_nprint_s *info, char *fmt, ... );
+
+	const char					*( *PhysInfo_ValueForKey )	( const char *key );
+	const char					*( *ServerInfo_ValueForKey )( const char *key );
+	float						( *GetClientMaxspeed )		( void );
+	int							( *CheckParm )				( char *parm, char **ppnext );
+	void						( *Key_Event )				( int key, int down );
+	void						( *GetMousePosition )		( int *mx, int *my );
+	int							( *IsNoClipping )			( void );
+
+	struct cl_entity_s			*( *GetLocalPlayer )		( void );
+	struct cl_entity_s			*( *GetViewModel )			( void );
+	struct cl_entity_s			*( *GetEntityByIndex )		( int idx );
+
+	float						( *GetClientTime )			( void );
+	void						( *V_CalcShake )			( void );
+	void						( *V_ApplyShake )			( float *origin, float *angles, float factor );
+
+	int							( *PM_PointContents )		( float *point, int *truecontents );
+	int							( *PM_WaterEntity )			( float *p );
+	struct pmtrace_s			*( *PM_TraceLine )			( float *start, float *end, int flags, int usehull, int ignore_pe );
+
+	struct model_s				*( *CL_LoadModel )			( const char *modelname, int *index );
+	int							( *CL_CreateVisibleEntity )	( int type, struct cl_entity_s *ent );
+
+	const struct model_s *		( *GetSpritePointer )		( HSPRITE hSprite );
+	void						( *pfnPlaySoundByNameAtLocation )	( char *szSound, float volume, float *origin );
+
+	unsigned short				( *pfnPrecacheEvent )		( int type, const char* psz );
+	void						( *pfnPlaybackEvent )		( int flags, const struct edict_s *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 );
+	void						( *pfnWeaponAnim )			( int iAnim, int body );
+	float						( *pfnRandomFloat )			( float flLow, float flHigh );
+	long						( *pfnRandomLong )			( long lLow, long lHigh );
+	void						( *pfnHookEvent )			( char *name, void ( *pfnEvent )( struct event_args_s *args ) );
+	int							(*Con_IsVisible)			();
+	const char					*( *pfnGetGameDirectory )	( void );
+	struct cvar_s				*( *pfnGetCvarPointer )		( const char *szName );
+	const char					*( *Key_LookupBinding )		( const char *pBinding );
+	const char					*( *pfnGetLevelName )		( void );
+	void						( *pfnGetScreenFade )		( struct screenfade_s *fade );
+	void						( *pfnSetScreenFade )		( struct screenfade_s *fade );
+	void                        *( *VGui_GetPanel )         ( );
+	void                         ( *VGui_ViewportPaintBackground ) (int extents[4]);
+
+	byte*						(*COM_LoadFile)				( char *path, int usehunk, int *pLength );
+	char*						(*COM_ParseFile)			( char *data, char *token );
+	void						(*COM_FreeFile)				( void *buffer );
+		
+	struct triangleapi_s		*pTriAPI;
+	struct efx_api_s			*pEfxAPI;
+	struct event_api_s			*pEventAPI;
+	struct demo_api_s			*pDemoAPI;
+	struct net_api_s			*pNetAPI;
+	struct IVoiceTweak_s		*pVoiceTweak;
+
+	// returns 1 if the client is a spectator only (connected to a proxy), 0 otherwise or 2 if in dev_overview mode
+	int							( *IsSpectateOnly ) ( void );
+	struct model_s				*( *LoadMapSprite )			( const char *filename );
+
+	// file search functions
+	void						( *COM_AddAppDirectoryToSearchPath ) ( const char *pszBaseDir, const char *appName );
+	int							( *COM_ExpandFilename)				 ( const char *fileName, char *nameOutBuffer, int nameOutBufferSize );
+
+	// User info
+	// playerNum is in the range (1, MaxClients)
+	// returns NULL if player doesn't exit
+	// returns "" if no value is set
+	const char					*( *PlayerInfo_ValueForKey )( int playerNum, const char *key );
+	void						( *PlayerInfo_SetValueForKey )( const char *key, const char *value );
+
+	// Gets a unique ID for the specified player. This is the same even if you see the player on a different server.
+	// iPlayer is an entity index, so client 0 would use iPlayer=1.
+	// Returns false if there is no player on the server in the specified slot.
+	qboolean					(*GetPlayerUniqueID)(int iPlayer, char playerID[16]);
+
+	// TrackerID access
+	int							(*GetTrackerIDForPlayer)(int playerSlot);
+	int							(*GetPlayerForTrackerID)(int trackerID);
+
+	// Same as pfnServerCmd, but the message goes in the unreliable stream so it can't clog the net stream
+	// (but it might not get there).
+	int							( *pfnServerCmdUnreliable )( char *szCmdString );
+
+	void						( *pfnGetMousePos )( struct tagPOINT *ppt );
+	void						( *pfnSetMousePos )( int x, int y );
+	void						( *pfnSetMouseEnable )( qboolean fEnable );
+} cl_enginefunc_t;
+
+#ifndef IN_BUTTONS_H
+#include "in_buttons.h"
+#endif
+
+#define CLDLL_INTERFACE_VERSION		7
+
+extern void ClientDLL_Init( void ); // from cdll_int.c
+extern void ClientDLL_Shutdown( void );
+extern void ClientDLL_HudInit( void );
+extern void ClientDLL_HudVidInit( void );
+extern void	ClientDLL_UpdateClientData( void );
+extern void ClientDLL_Frame( double time );
+extern void ClientDLL_HudRedraw( int intermission );
+extern void ClientDLL_MoveClient( struct playermove_s *ppmove );
+extern void ClientDLL_ClientMoveInit( struct playermove_s *ppmove );
+extern char ClientDLL_ClientTextureType( char *name );
+
+extern void ClientDLL_CreateMove( float frametime, struct usercmd_s *cmd, int active );
+extern void ClientDLL_ActivateMouse( void );
+extern void ClientDLL_DeactivateMouse( void );
+extern void ClientDLL_MouseEvent( int mstate );
+extern void ClientDLL_ClearStates( void );
+extern int ClientDLL_IsThirdPerson( void );
+extern void ClientDLL_GetCameraOffsets( float *ofs );
+extern int ClientDLL_GraphKeyDown( void );
+extern struct kbutton_s *ClientDLL_FindKey( const char *name );
+extern void ClientDLL_CAM_Think( void );
+extern void ClientDLL_IN_Accumulate( void );
+extern void ClientDLL_CalcRefdef( struct ref_params_s *pparams );
+extern int ClientDLL_AddEntity( int type, struct cl_entity_s *ent );
+extern void ClientDLL_CreateEntities( void );
+
+extern void ClientDLL_DrawNormalTriangles( void );
+extern void ClientDLL_DrawTransparentTriangles( void );
+extern void ClientDLL_StudioEvent( const struct mstudioevent_s *event, const struct cl_entity_s *entity );
+extern void ClientDLL_PostRunCmd( struct local_state_s *from, struct local_state_s *to, struct usercmd_s *cmd, int runfuncs, double time, unsigned int random_seed );
+extern void ClientDLL_TxferLocalOverrides( struct entity_state_s *state, const struct clientdata_s *client );
+extern void ClientDLL_ProcessPlayerState( struct entity_state_s *dst, const struct entity_state_s *src );
+extern void ClientDLL_TxferPredictionData ( struct entity_state_s *ps, const struct entity_state_s *pps, struct clientdata_s *pcd, const struct clientdata_s *ppcd, struct weapon_data_s *wd, const struct weapon_data_s *pwd );
+extern void ClientDLL_ReadDemoBuffer( int size, unsigned char *buffer );
+extern int ClientDLL_ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
+extern int ClientDLL_GetHullBounds( int hullnumber, float *mins, float *maxs );
+
+extern void ClientDLL_VGui_ConsolePrint(const char* text);
+
+extern int ClientDLL_Key_Event( int down, int keynum, const char *pszCurrentBinding );
+extern void ClientDLL_TempEntUpdate( double ft, double ct, double grav, struct tempent_s **ppFreeTE, struct tempent_s **ppActiveTE, int ( *addTEntity )( struct cl_entity_s *pEntity ), void ( *playTESound )( struct tempent_s *pTemp, float damp ) );
+extern struct cl_entity_s *ClientDLL_GetUserEntity( int index );
+extern void ClientDLL_VoiceStatus(int entindex, qboolean bTalking);
+extern void ClientDLL_DirectorMessage( int iSize, void *pbuf );
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // CDLL_INT_H
diff --git a/sdk/hlsdk/engine/custom.h b/sdk/hlsdk/engine/custom.h
new file mode 100644
index 0000000..79030ef
--- /dev/null
+++ b/sdk/hlsdk/engine/custom.h
@@ -0,0 +1,103 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+// Customization.h
+
+#ifndef CUSTOM_H
+#define CUSTOM_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#include "const.h"
+
+#define MAX_QPATH 64    // Must match value in quakedefs.h
+
+/////////////////
+// Customization
+// passed to pfnPlayerCustomization
+// For automatic downloading.
+typedef enum
+{
+	t_sound = 0,
+	t_skin,
+	t_model,
+	t_decal,
+	t_generic,
+	t_eventscript,
+	t_world,		// Fake type for world, is really t_model
+} resourcetype_t;
+
+
+typedef struct
+{
+	int				size;
+} _resourceinfo_t;
+
+typedef struct resourceinfo_s
+{
+	_resourceinfo_t info[ 8 ];
+} resourceinfo_t;
+
+#define RES_FATALIFMISSING (1<<0)   // Disconnect if we can't get this file.
+#define RES_WASMISSING     (1<<1)   // Do we have the file locally, did we get it ok?
+#define RES_CUSTOM         (1<<2)   // Is this resource one that corresponds to another player's customization
+								    //  or is it a server startup resource.
+#define RES_REQUESTED	   (1<<3)	// Already requested a download of this one
+#define RES_PRECACHED	   (1<<4)	// Already precached
+
+#include "crc.h"
+
+typedef struct resource_s
+{
+	char              szFileName[MAX_QPATH]; // File name to download/precache.
+	resourcetype_t    type;                // t_sound, t_skin, t_model, t_decal.
+	int               nIndex;              // For t_decals
+	int               nDownloadSize;       // Size in Bytes if this must be downloaded.
+	unsigned char     ucFlags;
+
+// For handling client to client resource propagation
+	unsigned char     rgucMD5_hash[16];    // To determine if we already have it.
+	unsigned char     playernum;           // Which player index this resource is associated with, if it's a custom resource.
+
+	unsigned char	  rguc_reserved[ 32 ]; // For future expansion
+	struct resource_s *pNext;              // Next in chain.
+	struct resource_s *pPrev;
+} resource_t;
+
+typedef struct customization_s
+{
+	qboolean bInUse;     // Is this customization in use;
+	resource_t resource; // The resource_t for this customization
+	qboolean bTranslated; // Has the raw data been translated into a useable format?  
+						   //  (e.g., raw decal .wad make into texture_t *)
+	int        nUserData1; // Customization specific data
+	int        nUserData2; // Customization specific data
+	void *pInfo;          // Buffer that holds the data structure that references the data (e.g., the cachewad_t)
+	void *pBuffer;       // Buffer that holds the data for the customization (the raw .wad data)
+	struct customization_s *pNext; // Next in chain
+} customization_t;
+
+#define FCUST_FROMHPAK		( 1<<0 )
+#define FCUST_WIPEDATA		( 1<<1 )
+#define FCUST_IGNOREINIT	( 1<<2 )
+
+void		COM_ClearCustomizationList( struct customization_s *pHead, qboolean bCleanDecals);
+qboolean	COM_CreateCustomization( struct customization_s *pListHead, struct resource_s *pResource, int playernumber, int flags, 
+				struct customization_s **pCustomization, int *nLumps ); 
+int			COM_SizeofResourceList ( struct resource_s *pList, struct resourceinfo_s *ri );
+
+#endif // CUSTOM_H
diff --git a/sdk/hlsdk/engine/customentity.h b/sdk/hlsdk/engine/customentity.h
new file mode 100644
index 0000000..0895bee
--- /dev/null
+++ b/sdk/hlsdk/engine/customentity.h
@@ -0,0 +1,38 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef CUSTOMENTITY_H
+#define CUSTOMENTITY_H
+
+// Custom Entities
+
+// Start/End Entity is encoded as 12 bits of entity index, and 4 bits of attachment (4:12)
+#define BEAMENT_ENTITY(x)		((x)&0xFFF)
+#define BEAMENT_ATTACHMENT(x)	(((x)>>12)&0xF)
+
+// Beam types, encoded as a byte
+enum 
+{
+	BEAM_POINTS = 0,
+	BEAM_ENTPOINT,
+	BEAM_ENTS,
+	BEAM_HOSE,
+};
+
+#define BEAM_FSINE		0x10
+#define BEAM_FSOLID		0x20
+#define BEAM_FSHADEIN	0x40
+#define BEAM_FSHADEOUT	0x80
+
+#endif	//CUSTOMENTITY_H
diff --git a/sdk/hlsdk/engine/edict.h b/sdk/hlsdk/engine/edict.h
new file mode 100644
index 0000000..cd55083
--- /dev/null
+++ b/sdk/hlsdk/engine/edict.h
@@ -0,0 +1,38 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#if !defined EDICT_H
+#define EDICT_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+#define	MAX_ENT_LEAFS	48
+
+#include "progdefs.h"
+
+struct edict_s
+{
+	qboolean	free;				// +4
+	int			serialnumber;		// +4
+	link_t		area;				// +8 linked to a division node or leaf
+	
+	int			headnode;			// -1 to use normal leaf check || *((int *)pthis + 4)
+	int			num_leafs;
+	short		leafnums[MAX_ENT_LEAFS];
+
+	float		freetime;			// sv.time when the object was freed
+
+	void*		pvPrivateData;		// Alloced and freed by engine, used by DLLs
+
+	entvars_t	v;					// C exported fields from progs
+
+	// other fields from progs come immediately after
+};
+
+#endif
diff --git a/sdk/hlsdk/engine/eiface.h b/sdk/hlsdk/engine/eiface.h
new file mode 100644
index 0000000..d1409aa
--- /dev/null
+++ b/sdk/hlsdk/engine/eiface.h
@@ -0,0 +1,528 @@
+/***
+*
+*	Copyright (c) 1999, 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.
+*
+****/
+#ifndef EIFACE_H
+#define EIFACE_H
+
+#include "archtypes.h"     // DAL
+
+#ifdef HLDEMO_BUILD
+#define INTERFACE_VERSION       001
+#else  // !HLDEMO_BUILD, i.e., regular version of HL
+#define INTERFACE_VERSION		140
+#endif // !HLDEMO_BUILD
+
+#include <stdio.h>
+#include "custom.h"
+#include "cvardef.h"
+#include "Sequence.h"
+//
+// Defines entity interface between engine and DLLs.
+// This header file included by engine files and DLL files.
+//
+// Before including this header, DLLs must:
+//		include progdefs.h
+// This is conveniently done for them in extdll.h
+//
+
+#ifdef _WIN32
+#define DLLEXPORT __stdcall
+#else
+#define DLLEXPORT /* */
+#endif
+
+typedef enum
+	{
+	at_notice,
+	at_console,		// same as at_notice, but forces a ConPrintf, not a message box
+	at_aiconsole,	// same as at_console, but only shown if developer level is 2!
+	at_warning,
+	at_error,
+	at_logged		// Server print to console ( only in multiplayer games ).
+	} ALERT_TYPE;
+
+// 4-22-98  JOHN: added for use in pfnClientPrintf
+typedef enum
+	{
+	print_console,
+	print_center,
+	print_chat,
+	} PRINT_TYPE;
+
+// For integrity checking of content on clients
+typedef enum
+{
+	force_exactfile,					// File on client must exactly match server's file
+	force_model_samebounds,				// For model files only, the geometry must fit in the same bbox
+	force_model_specifybounds,			// For model files only, the geometry must fit in the specified bbox
+	force_model_specifybounds_if_avail,	// For Steam model files only, the geometry must fit in the specified bbox (if the file is available)
+} FORCE_TYPE;
+
+// Returned by TraceLine
+typedef struct
+	{
+	int		fAllSolid;			// if true, plane is not valid
+	int		fStartSolid;		// if true, the initial point was in a solid area
+	int		fInOpen;
+	int		fInWater;
+	float	flFraction;			// time completed, 1.0 = didn't hit anything
+	vec3_t	vecEndPos;			// final position
+	float	flPlaneDist;
+	vec3_t	vecPlaneNormal;		// surface normal at impact
+	edict_t	*pHit;				// entity the surface is on
+	int		iHitgroup;			// 0 == generic, non zero is specific body part
+	} TraceResult;
+
+// CD audio status
+typedef struct 
+{
+	int	fPlaying;// is sound playing right now?
+	int	fWasPlaying;// if not, CD is paused if WasPlaying is true.
+	int	fInitialized;
+	int	fEnabled;
+	int	fPlayLooping;
+	float	cdvolume;
+	//BYTE 	remap[100];
+	int	fCDRom;
+	int	fPlayTrack;
+} CDStatus;
+
+#include "../common/crc.h"
+
+
+// Engine hands this to DLLs for functionality callbacks
+typedef struct enginefuncs_s
+{
+	int			(*pfnPrecacheModel)			(char* s);
+	int			(*pfnPrecacheSound)			(char* s);
+	void		(*pfnSetModel)				(edict_t *e, const char *m);
+	int			(*pfnModelIndex)			(const char *m);
+	int			(*pfnModelFrames)			(int modelIndex);
+	void		(*pfnSetSize)				(edict_t *e, const float *rgflMin, const float *rgflMax);
+	void		(*pfnChangeLevel)			(char* s1, char* s2);
+	void		(*pfnGetSpawnParms)			(edict_t *ent);
+	void		(*pfnSaveSpawnParms)		(edict_t *ent);
+	float		(*pfnVecToYaw)				(const float *rgflVector);
+	void		(*pfnVecToAngles)			(const float *rgflVectorIn, float *rgflVectorOut);
+	void		(*pfnMoveToOrigin)			(edict_t *ent, const float *pflGoal, float dist, int iMoveType);
+	void		(*pfnChangeYaw)				(edict_t* ent);
+	void		(*pfnChangePitch)			(edict_t* ent);
+	edict_t*	(*pfnFindEntityByString)	(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue);
+	int			(*pfnGetEntityIllum)		(edict_t* pEnt);
+	edict_t*	(*pfnFindEntityInSphere)	(edict_t *pEdictStartSearchAfter, const float *org, float rad);
+	edict_t*	(*pfnFindClientInPVS)		(edict_t *pEdict);
+	edict_t* (*pfnEntitiesInPVS)			(edict_t *pplayer);
+	void		(*pfnMakeVectors)			(const float *rgflVector);
+	void		(*pfnAngleVectors)			(const float *rgflVector, float *forward, float *right, float *up);
+	edict_t*	(*pfnCreateEntity)			(void);
+	void		(*pfnRemoveEntity)			(edict_t* e);
+	edict_t*	(*pfnCreateNamedEntity)		(int className);
+	void		(*pfnMakeStatic)			(edict_t *ent);
+	int			(*pfnEntIsOnFloor)			(edict_t *e);
+	int			(*pfnDropToFloor)			(edict_t* e);
+	int			(*pfnWalkMove)				(edict_t *ent, float yaw, float dist, int iMode);
+	void		(*pfnSetOrigin)				(edict_t *e, const float *rgflOrigin);
+	void		(*pfnEmitSound)				(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch);
+	void		(*pfnEmitAmbientSound)		(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch);
+	void		(*pfnTraceLine)				(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+	void		(*pfnTraceToss)				(edict_t* pent, edict_t* pentToIgnore, TraceResult *ptr);
+	int			(*pfnTraceMonsterHull)		(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+	void		(*pfnTraceHull)				(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr);
+	void		(*pfnTraceModel)			(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr);
+	const char *(*pfnTraceTexture)			(edict_t *pTextureEntity, const float *v1, const float *v2 );
+	void		(*pfnTraceSphere)			(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr);
+	void		(*pfnGetAimVector)			(edict_t* ent, float speed, float *rgflReturn);
+	void		(*pfnServerCommand)			(char* str);
+	void		(*pfnServerExecute)			(void);
+	void		(*pfnClientCommand)			(edict_t* pEdict, char* szFmt, ...);
+	void		(*pfnParticleEffect)		(const float *org, const float *dir, float color, float count);
+	void		(*pfnLightStyle)			(int style, char* val);
+	int			(*pfnDecalIndex)			(const char *name);
+	int			(*pfnPointContents)			(const float *rgflVector);
+	void		(*pfnMessageBegin)			(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+	void		(*pfnMessageEnd)			(void);
+	void		(*pfnWriteByte)				(int iValue);
+	void		(*pfnWriteChar)				(int iValue);
+	void		(*pfnWriteShort)			(int iValue);
+	void		(*pfnWriteLong)				(int iValue);
+	void		(*pfnWriteAngle)			(float flValue);
+	void		(*pfnWriteCoord)			(float flValue);
+	void		(*pfnWriteString)			(const char *sz);
+	void		(*pfnWriteEntity)			(int iValue);
+	void		(*pfnCVarRegister)			(cvar_t *pCvar);
+	float		(*pfnCVarGetFloat)			(const char *szVarName);
+	const char*	(*pfnCVarGetString)			(const char *szVarName);
+	void		(*pfnCVarSetFloat)			(const char *szVarName, float flValue);
+	void		(*pfnCVarSetString)			(const char *szVarName, const char *szValue);
+	void		(*pfnAlertMessage)			(ALERT_TYPE atype, char *szFmt, ...);
+	void		(*pfnEngineFprintf)			(void *pfile, char *szFmt, ...);
+	void*		(*pfnPvAllocEntPrivateData)	(edict_t *pEdict, int32 cb);
+	void*		(*pfnPvEntPrivateData)		(edict_t *pEdict);
+	void		(*pfnFreeEntPrivateData)	(edict_t *pEdict);
+	const char*	(*pfnSzFromIndex)			(int iString);
+	int			(*pfnAllocString)			(const char *szValue);
+	struct entvars_s*	(*pfnGetVarsOfEnt)			(edict_t *pEdict);
+	edict_t*	(*pfnPEntityOfEntOffset)	(int iEntOffset);
+	int			(*pfnEntOffsetOfPEntity)	(const edict_t *pEdict);
+	int			(*pfnIndexOfEdict)			(const edict_t *pEdict);
+	edict_t*	(*pfnPEntityOfEntIndex)		(int iEntIndex);
+	edict_t*	(*pfnFindEntityByVars)		(struct entvars_s* pvars);
+	void*		(*pfnGetModelPtr)			(edict_t* pEdict);
+	int			(*pfnRegUserMsg)			(const char *pszName, int iSize);
+	void		(*pfnAnimationAutomove)		(const edict_t* pEdict, float flTime);
+	void		(*pfnGetBonePosition)		(const edict_t* pEdict, int iBone, float *rgflOrigin, float *rgflAngles );
+	uint32 (*pfnFunctionFromName)	( const char *pName );
+	const char *(*pfnNameForFunction)		( uint32 function );
+	void		(*pfnClientPrintf)			( edict_t* pEdict, PRINT_TYPE ptype, const char *szMsg ); // JOHN: engine callbacks so game DLL can print messages to individual clients
+	void		(*pfnServerPrint)			( const char *szMsg );
+	const char *(*pfnCmd_Args)				( void );		// these 3 added 
+	const char *(*pfnCmd_Argv)				( int argc );	// so game DLL can easily 
+	int			(*pfnCmd_Argc)				( void );		// access client 'cmd' strings
+	void		(*pfnGetAttachment)			(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles );
+	void		(*pfnCRC32_Init)			(CRC32_t *pulCRC);
+	void        (*pfnCRC32_ProcessBuffer)   (CRC32_t *pulCRC, void *p, int len);
+	void		(*pfnCRC32_ProcessByte)     (CRC32_t *pulCRC, unsigned char ch);
+	CRC32_t		(*pfnCRC32_Final)			(CRC32_t pulCRC);
+	int32		(*pfnRandomLong)			(int32  lLow,  int32  lHigh);
+	float		(*pfnRandomFloat)			(float flLow, float flHigh);
+	void		(*pfnSetView)				(const edict_t *pClient, const edict_t *pViewent );
+	float		(*pfnTime)					( void );
+	void		(*pfnCrosshairAngle)		(const edict_t *pClient, float pitch, float yaw);
+	byte *      (*pfnLoadFileForMe)         (char *filename, int *pLength);
+	void        (*pfnFreeFile)              (void *buffer);
+	void        (*pfnEndSection)            (const char *pszSectionName); // trigger_endsection
+	int 		(*pfnCompareFileTime)       (char *filename1, char *filename2, int *iCompare);
+	void        (*pfnGetGameDir)            (char *szGetGameDir);
+	void		(*pfnCvar_RegisterVariable) (cvar_t *variable);
+	void        (*pfnFadeClientVolume)      (const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds);
+	void        (*pfnSetClientMaxspeed)     (const edict_t *pEdict, float fNewMaxspeed);
+	edict_t *	(*pfnCreateFakeClient)		(const char *netname);	// returns NULL if fake client can't be created
+	void		(*pfnRunPlayerMove)			(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec );
+	int			(*pfnNumberOfEntities)		(void);
+	char*		(*pfnGetInfoKeyBuffer)		(edict_t *e);	// passing in NULL gets the serverinfo
+	char*		(*pfnInfoKeyValue)			(char *infobuffer, char *key);
+	void		(*pfnSetKeyValue)			(char *infobuffer, char *key, char *value);
+	void		(*pfnSetClientKeyValue)		(int clientIndex, char *infobuffer, char *key, char *value);
+	int			(*pfnIsMapValid)			(char *filename);
+	void		(*pfnStaticDecal)			( const float *origin, int decalIndex, int entityIndex, int modelIndex );
+	int			(*pfnPrecacheGeneric)		(char* s);
+	int			(*pfnGetPlayerUserId)		(edict_t *e ); // returns the server assigned userid for this player.  useful for logging frags, etc.  returns -1 if the edict couldn't be found in the list of clients
+	void		(*pfnBuildSoundMsg)			(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);
+	int			(*pfnIsDedicatedServer)		(void);// is this a dedicated server?
+	cvar_t		*(*pfnCVarGetPointer)		(const char *szVarName);
+	unsigned int (*pfnGetPlayerWONId)		(edict_t *e); // returns the server assigned WONid for this player.  useful for logging frags, etc.  returns -1 if the edict couldn't be found in the list of clients
+
+	// YWB 8/1/99 TFF Physics additions
+	void		(*pfnInfo_RemoveKey)		( char *s, const char *key );
+	const char *(*pfnGetPhysicsKeyValue)	( const edict_t *pClient, const char *key );
+	void		(*pfnSetPhysicsKeyValue)	( const edict_t *pClient, const char *key, const char *value );
+	const char *(*pfnGetPhysicsInfoString)	( const edict_t *pClient );
+	unsigned short (*pfnPrecacheEvent)		( int type, const char*psz );
+	void		(*pfnPlaybackEvent)			( 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 );
+
+	unsigned char *(*pfnSetFatPVS)			( float *org );
+	unsigned char *(*pfnSetFatPAS)			( float *org );
+
+	int			(*pfnCheckVisibility )		( const edict_t *entity, unsigned char *pset );
+
+	void		(*pfnDeltaSetField)			( struct delta_s *pFields, const char *fieldname );
+	void		(*pfnDeltaUnsetField)		( struct delta_s *pFields, const char *fieldname );
+	void		(*pfnDeltaAddEncoder)		( char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) );
+	int			(*pfnGetCurrentPlayer)		( void );
+	int			(*pfnCanSkipPlayer)			( const edict_t *player );
+	int			(*pfnDeltaFindField)		( struct delta_s *pFields, const char *fieldname );
+	void		(*pfnDeltaSetFieldByIndex)	( struct delta_s *pFields, int fieldNumber );
+	void		(*pfnDeltaUnsetFieldByIndex)( struct delta_s *pFields, int fieldNumber );
+
+	void		(*pfnSetGroupMask)			( int mask, int op );
+
+	int			(*pfnCreateInstancedBaseline) ( int classname, struct entity_state_s *baseline );
+	void		(*pfnCvar_DirectSet)		( struct cvar_s *var, char *value );
+
+	// Forces the client and server to be running with the same version of the specified file
+	//  ( e.g., a player model ).
+	// Calling this has no effect in single player
+	void		(*pfnForceUnmodified)		( FORCE_TYPE type, float *mins, float *maxs, const char *filename );
+
+	void		(*pfnGetPlayerStats)		( const edict_t *pClient, int *ping, int *packet_loss );
+
+	void		(*pfnAddServerCommand)		( char *cmd_name, void (*function) (void) );
+
+	// For voice communications, set which clients hear eachother.
+	// NOTE: these functions take player entity indices (starting at 1).
+	qboolean	(*pfnVoice_GetClientListening)(int iReceiver, int iSender);
+	qboolean	(*pfnVoice_SetClientListening)(int iReceiver, int iSender, qboolean bListen);
+
+	const char *(*pfnGetPlayerAuthId)		( edict_t *e );
+
+	// PSV: Added for CZ training map
+//	const char *(*pfnKeyNameForBinding)					( const char* pBinding );
+	
+	sequenceEntry_s*	(*pfnSequenceGet)				( const char* fileName, const char* entryName );
+	sentenceEntry_s*	(*pfnSequencePickSentence)		( const char* groupName, int pickMethod, int *picked );
+
+	// LH: Give access to filesize via filesystem
+	int			(*pfnGetFileSize)						( char *filename );
+
+	unsigned int (*pfnGetApproxWavePlayLen)				(const char *filepath);
+	// MDC: Added for CZ career-mode
+	int			(*pfnIsCareerMatch)						( void );
+
+	// BGC: return the number of characters of the localized string referenced by using "label"
+	int			(*pfnGetLocalizedStringLength)			(const char *label);
+
+	// BGC: added to facilitate persistent storage of tutor message decay values for
+	// different career game profiles.  Also needs to persist regardless of mp.dll being
+	// destroyed and recreated.
+	void		(*pfnRegisterTutorMessageShown)			(int mid);
+	int			(*pfnGetTimesTutorMessageShown)			(int mid);
+	void		(*pfnProcessTutorMessageDecayBuffer)	(int *buffer, int bufferLength);
+	void		(*pfnConstructTutorMessageDecayBuffer)	(int *buffer, int bufferLength);
+	void		(*pfnResetTutorMessageDecayData)		( void );
+	void		(*pfnQueryClientCvarValue)				( const edict_t *player, const char *cvarName );
+    void        (*pfnQueryClientCvarValue2)             ( const edict_t *player, const char *cvarName, int requestID );
+} enginefuncs_t;
+
+
+// ONLY ADD NEW FUNCTIONS TO THE END OF THIS STRUCT.  INTERFACE VERSION IS FROZEN AT 138
+
+// Passed to pfnKeyValue
+typedef struct KeyValueData_s
+{
+	char	*szClassName;	// in: entity classname
+	char	*szKeyName;		// in: name of key
+	char	*szValue;		// in: value of key
+	int32	fHandled;		// out: DLL sets to true if key-value pair was understood
+} KeyValueData;
+
+
+typedef struct
+{
+	char		mapName[ 32 ];
+	char		landmarkName[ 32 ];
+	edict_t	*pentLandmark;
+	vec3_t		vecLandmarkOrigin;
+} LEVELLIST;
+#define MAX_LEVEL_CONNECTIONS	16		// These are encoded in the lower 16bits of ENTITYTABLE->flags
+
+typedef struct 
+{
+	int			id;				// Ordinal ID of this entity (used for entity <--> pointer conversions)
+	edict_t	*pent;			// Pointer to the in-game entity
+
+	int			location;		// Offset from the base data of this entity
+	int			size;			// Byte size of this entity's data
+	int			flags;			// This could be a short -- bit mask of transitions that this entity is in the PVS of
+	string_t	classname;		// entity class name
+
+} ENTITYTABLE;
+
+#define FENTTABLE_PLAYER		0x80000000
+#define FENTTABLE_REMOVED		0x40000000
+#define FENTTABLE_MOVEABLE		0x20000000
+#define FENTTABLE_GLOBAL		0x10000000
+
+typedef struct saverestore_s SAVERESTOREDATA;
+
+#ifdef _WIN32
+typedef 
+#endif
+struct saverestore_s
+{
+	char		*pBaseData;		// Start of all entity save data
+	char		*pCurrentData;	// Current buffer pointer for sequential access
+	int			size;			// Current data size
+	int			bufferSize;		// Total space for data
+	int			tokenSize;		// Size of the linear list of tokens
+	int			tokenCount;		// Number of elements in the pTokens table
+	char		**pTokens;		// Hash table of entity strings (sparse)
+	int			currentIndex;	// Holds a global entity table ID
+	int			tableCount;		// Number of elements in the entity table
+	int			connectionCount;// Number of elements in the levelList[]
+	ENTITYTABLE	*pTable;		// Array of ENTITYTABLE elements (1 for each entity)
+	LEVELLIST	levelList[ MAX_LEVEL_CONNECTIONS ];		// List of connections from this level
+
+	// smooth transition
+	int			fUseLandmark;
+	char		szLandmarkName[20];// landmark we'll spawn near in next level
+	vec3_t		vecLandmarkOffset;// for landmark transitions
+	float		time;
+	char		szCurrentMapName[32];	// To check global entities
+
+} 
+#ifdef _WIN32
+SAVERESTOREDATA 
+#endif
+;
+
+typedef enum _fieldtypes
+{
+	FIELD_FLOAT = 0,		// Any floating point value
+	FIELD_STRING,			// A string ID (return from ALLOC_STRING)
+	FIELD_ENTITY,			// An entity offset (EOFFSET)
+	FIELD_CLASSPTR,			// CBaseEntity *
+	FIELD_EHANDLE,			// Entity handle
+	FIELD_EVARS,			// EVARS *
+	FIELD_EDICT,			// edict_t *, or edict_t *  (same thing)
+	FIELD_VECTOR,			// Any vector
+	FIELD_POSITION_VECTOR,	// A world coordinate (these are fixed up across level transitions automagically)
+	FIELD_POINTER,			// Arbitrary data pointer... to be removed, use an array of FIELD_CHARACTER
+	FIELD_INTEGER,			// Any integer or enum
+	FIELD_FUNCTION,			// A class function pointer (Think, Use, etc)
+	FIELD_BOOLEAN,			// boolean, implemented as an int, I may use this as a hint for compression
+	FIELD_SHORT,			// 2 byte integer
+	FIELD_CHARACTER,		// a byte
+	FIELD_TIME,				// a floating point time (these are fixed up automatically too!)
+	FIELD_MODELNAME,		// Engine string that is a model name (needs precache)
+	FIELD_SOUNDNAME,		// Engine string that is a sound name (needs precache)
+
+	FIELD_TYPECOUNT,		// MUST BE LAST
+} FIELDTYPE;
+
+#ifndef offsetof
+#define offsetof(s,m)	(size_t)&(((s *)0)->m)
+#endif
+
+#define _FIELD(type,name,fieldtype,count,flags)		{ fieldtype, #name, offsetof(type, name), count, flags }
+#define DEFINE_FIELD(type,name,fieldtype)			_FIELD(type, name, fieldtype, 1, 0)
+#define DEFINE_ARRAY(type,name,fieldtype,count)		_FIELD(type, name, fieldtype, count, 0)
+#define DEFINE_ENTITY_FIELD(name,fieldtype)			_FIELD(entvars_t, name, fieldtype, 1, 0 )
+#define DEFINE_ENTITY_GLOBAL_FIELD(name,fieldtype)	_FIELD(entvars_t, name, fieldtype, 1, FTYPEDESC_GLOBAL )
+#define DEFINE_GLOBAL_FIELD(type,name,fieldtype)	_FIELD(type, name, fieldtype, 1, FTYPEDESC_GLOBAL )
+
+
+#define FTYPEDESC_GLOBAL			0x0001		// This field is masked for global entity save/restore
+
+typedef struct 
+{
+	FIELDTYPE		fieldType;
+	char			*fieldName;
+	int				fieldOffset;
+	short			fieldSize;
+	short			flags;
+} TYPEDESCRIPTION;
+
+#define HLARRAYSIZE(p)		(sizeof(p)/sizeof(p[0]))
+
+typedef struct 
+{
+	// Initialize/shutdown the game (one-time call after loading of game .dll )
+	void			(*pfnGameInit)			( void );				
+	int				(*pfnSpawn)				( edict_t *pent );
+	void			(*pfnThink)				( edict_t *pent );
+	void			(*pfnUse)				( edict_t *pentUsed, edict_t *pentOther );
+	void			(*pfnTouch)				( edict_t *pentTouched, edict_t *pentOther );
+	void			(*pfnBlocked)			( edict_t *pentBlocked, edict_t *pentOther );
+	void			(*pfnKeyValue)			( edict_t *pentKeyvalue, KeyValueData *pkvd );
+	void			(*pfnSave)				( edict_t *pent, SAVERESTOREDATA *pSaveData );
+	int 			(*pfnRestore)			( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity );
+	void			(*pfnSetAbsBox)			( edict_t *pent );
+
+	void			(*pfnSaveWriteFields)	( SAVERESTOREDATA *, const char *, void *, TYPEDESCRIPTION *, int );
+	void			(*pfnSaveReadFields)	( SAVERESTOREDATA *, const char *, void *, TYPEDESCRIPTION *, int );
+
+	void			(*pfnSaveGlobalState)		( SAVERESTOREDATA * );
+	void			(*pfnRestoreGlobalState)	( SAVERESTOREDATA * );
+	void			(*pfnResetGlobalState)		( void );
+
+	qboolean		(*pfnClientConnect)		( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] );
+	
+	void			(*pfnClientDisconnect)	( edict_t *pEntity );
+	void			(*pfnClientKill)		( edict_t *pEntity );
+	void			(*pfnClientPutInServer)	( edict_t *pEntity );
+	void			(*pfnClientCommand)		( edict_t *pEntity );
+	void			(*pfnClientUserInfoChanged)( edict_t *pEntity, char *infobuffer );
+
+	void			(*pfnServerActivate)	( edict_t *pEdictList, int edictCount, int clientMax );
+	void			(*pfnServerDeactivate)	( void );
+
+	void			(*pfnPlayerPreThink)	( edict_t *pEntity );
+	void			(*pfnPlayerPostThink)	( edict_t *pEntity );
+
+	void			(*pfnStartFrame)		( void );
+	void			(*pfnParmsNewLevel)		( void );
+	void			(*pfnParmsChangeLevel)	( void );
+
+	 // Returns string describing current .dll.  E.g., TeamFotrress 2, Half-Life
+	const char     *(*pfnGetGameDescription)( void );     
+
+	// Notify dll about a player customization.
+	void            (*pfnPlayerCustomization) ( edict_t *pEntity, customization_t *pCustom );  
+
+	// Spectator funcs
+	void			(*pfnSpectatorConnect)		( edict_t *pEntity );
+	void			(*pfnSpectatorDisconnect)	( edict_t *pEntity );
+	void			(*pfnSpectatorThink)		( edict_t *pEntity );
+
+	// Notify game .dll that engine is going to shut down.  Allows mod authors to set a breakpoint.
+	void			(*pfnSys_Error)			( const char *error_string );
+
+	void			(*pfnPM_Move) ( struct playermove_s *ppmove, qboolean server );
+	void			(*pfnPM_Init) ( struct playermove_s *ppmove );
+	char			(*pfnPM_FindTextureType)( char *name );
+	void			(*pfnSetupVisibility)( struct edict_s *pViewEntity, struct edict_s *pClient, unsigned char **pvs, unsigned char **pas );
+	void			(*pfnUpdateClientData) ( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd );
+	int				(*pfnAddToFullPack)( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet );
+	void			(*pfnCreateBaseline) ( int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs );
+	void			(*pfnRegisterEncoders)	( void );
+	int				(*pfnGetWeaponData)		( struct edict_s *player, struct weapon_data_s *info );
+
+	void			(*pfnCmdStart)			( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed );
+	void			(*pfnCmdEnd)			( const edict_t *player );
+
+	// Return 1 if the packet is valid.  Set response_buffer_size if you want to send a response packet.  Incoming, it holds the max
+	//  size of the response_buffer, so you must zero it out if you choose not to respond.
+	int				(*pfnConnectionlessPacket )	( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
+
+	// Enumerates player hulls.  Returns 0 if the hull number doesn't exist, 1 otherwise
+	int				(*pfnGetHullBounds)	( int hullnumber, float *mins, float *maxs );
+
+	// Create baselines for certain "unplaced" items.
+	void			(*pfnCreateInstancedBaselines) ( void );
+
+	// One of the pfnForceUnmodified files failed the consistency check for the specified player
+	// Return 0 to allow the client to continue, 1 to force immediate disconnection ( with an optional disconnect message of up to 256 characters )
+	int				(*pfnInconsistentFile)( const struct edict_s *player, const char *filename, char *disconnect_message );
+
+	// The game .dll should return 1 if lag compensation should be allowed ( could also just set
+	//  the sv_unlag cvar.
+	// Most games right now should return 0, until client-side weapon prediction code is written
+	//  and tested for them.
+	int				(*pfnAllowLagCompensation)( void );
+} DLL_FUNCTIONS;
+
+extern DLL_FUNCTIONS		gEntityInterface;
+
+// Current version.
+#define NEW_DLL_FUNCTIONS_VERSION	1
+
+typedef struct
+{
+	// Called right before the object's memory is freed. 
+	// Calls its destructor.
+	void			(*pfnOnFreeEntPrivateData)(edict_t *pEnt);
+	void			(*pfnGameShutdown)(void);
+	int				(*pfnShouldCollide)( edict_t *pentTouched, edict_t *pentOther );
+	void			(*pfnCvarValue)( const edict_t *pEnt, const char *value );
+    void            (*pfnCvarValue2)( const edict_t *pEnt, int requestID, const char *cvarName, const char *value );
+} NEW_DLL_FUNCTIONS;
+typedef int	(*NEW_DLL_FUNCTIONS_FN)( NEW_DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion );
+
+// Pointers will be null if the game DLL doesn't support this API.
+extern NEW_DLL_FUNCTIONS	gNewDLLFunctions;
+
+typedef int	(*APIFUNCTION)( DLL_FUNCTIONS *pFunctionTable, int interfaceVersion );
+typedef int	(*APIFUNCTION2)( DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion );
+
+#endif /* EIFACE_H */
diff --git a/sdk/hlsdk/engine/keydefs.h b/sdk/hlsdk/engine/keydefs.h
new file mode 100644
index 0000000..ef9b2fc
--- /dev/null
+++ b/sdk/hlsdk/engine/keydefs.h
@@ -0,0 +1,131 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+// keydefs.h
+#ifndef KEYDEFS_H
+#define KEYDEFS_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+//
+// these are the key numbers that should be passed to Key_Event
+//
+#define	K_TAB			9
+#define	K_ENTER			13
+#define	K_ESCAPE		27
+#define	K_SPACE			32
+
+// normal keys should be passed as lowercased ascii
+
+#define	K_BACKSPACE		127
+#define	K_UPARROW		128
+#define	K_DOWNARROW		129
+#define	K_LEFTARROW		130
+#define	K_RIGHTARROW	131
+
+#define	K_ALT			132
+#define	K_CTRL			133
+#define	K_SHIFT			134
+#define	K_F1			135
+#define	K_F2			136
+#define	K_F3			137
+#define	K_F4			138
+#define	K_F5			139
+#define	K_F6			140
+#define	K_F7			141
+#define	K_F8			142
+#define	K_F9			143
+#define	K_F10			144
+#define	K_F11			145
+#define	K_F12			146
+#define	K_INS			147
+#define	K_DEL			148
+#define	K_PGDN			149
+#define	K_PGUP			150
+#define	K_HOME			151
+#define	K_END			152
+
+#define K_KP_HOME		160
+#define K_KP_UPARROW	161
+#define K_KP_PGUP		162
+#define	K_KP_LEFTARROW	163
+#define K_KP_5			164
+#define K_KP_RIGHTARROW	165
+#define K_KP_END		166
+#define K_KP_DOWNARROW	167
+#define K_KP_PGDN		168
+#define	K_KP_ENTER		169
+#define K_KP_INS   		170
+#define	K_KP_DEL		171
+#define K_KP_SLASH		172
+#define K_KP_MINUS		173
+#define K_KP_PLUS		174
+#define K_CAPSLOCK		175
+
+
+//
+// joystick buttons
+//
+#define	K_JOY1			203
+#define	K_JOY2			204
+#define	K_JOY3			205
+#define	K_JOY4			206
+
+//
+// aux keys are for multi-buttoned joysticks to generate so they can use
+// the normal binding process
+//
+#define	K_AUX1			207
+#define	K_AUX2			208
+#define	K_AUX3			209
+#define	K_AUX4			210
+#define	K_AUX5			211
+#define	K_AUX6			212
+#define	K_AUX7			213
+#define	K_AUX8			214
+#define	K_AUX9			215
+#define	K_AUX10			216
+#define	K_AUX11			217
+#define	K_AUX12			218
+#define	K_AUX13			219
+#define	K_AUX14			220
+#define	K_AUX15			221
+#define	K_AUX16			222
+#define	K_AUX17			223
+#define	K_AUX18			224
+#define	K_AUX19			225
+#define	K_AUX20			226
+#define	K_AUX21			227
+#define	K_AUX22			228
+#define	K_AUX23			229
+#define	K_AUX24			230
+#define	K_AUX25			231
+#define	K_AUX26			232
+#define	K_AUX27			233
+#define	K_AUX28			234
+#define	K_AUX29			235
+#define	K_AUX30			236
+#define	K_AUX31			237
+#define	K_AUX32			238
+#define K_MWHEELDOWN	239
+#define K_MWHEELUP		240
+
+#define K_PAUSE			255
+
+//
+// mouse buttons generate virtual keys
+//
+#define	K_MOUSE1		241
+#define	K_MOUSE2		242
+#define	K_MOUSE3		243
+#define K_MOUSE4		244
+#define K_MOUSE5		245
+
+#endif // KEYDEFS_H
diff --git a/sdk/hlsdk/engine/progdefs.h b/sdk/hlsdk/engine/progdefs.h
new file mode 100644
index 0000000..c7b9855
--- /dev/null
+++ b/sdk/hlsdk/engine/progdefs.h
@@ -0,0 +1,226 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef PROGDEFS_H
+#define PROGDEFS_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+typedef struct
+{	
+	float		time;
+	float		frametime;
+	float		force_retouch;
+	string_t	mapname;
+	string_t	startspot;
+	float		deathmatch;
+	float		coop;
+	float		teamplay;
+	float		serverflags;
+	float		found_secrets;
+	vec3_t		v_forward;
+	vec3_t		v_up;
+	vec3_t		v_right;
+	float		trace_allsolid;
+	float		trace_startsolid;
+	float		trace_fraction;
+	vec3_t		trace_endpos;
+	vec3_t		trace_plane_normal;
+	float		trace_plane_dist;
+	edict_t		*trace_ent;
+	float		trace_inopen;
+	float		trace_inwater;
+	int			trace_hitgroup;
+	int			trace_flags;
+	int			msg_entity;
+	int			cdAudioTrack;
+	int			maxClients;
+	int			maxEntities;
+	const char	*pStringBase;
+
+	void		*pSaveData;
+	vec3_t		vecLandmarkOffset;
+} globalvars_t;
+
+
+typedef struct entvars_s
+{
+	string_t	classname;
+	string_t	globalname;
+
+	vec3_t		origin;
+	vec3_t		oldorigin;
+	vec3_t		velocity;
+	vec3_t		basevelocity;
+	vec3_t      clbasevelocity;  // Base velocity that was passed in to server physics so 
+							     //  client can predict conveyors correctly.  Server zeroes it, so we need to store here, too.
+	vec3_t		movedir;
+
+	vec3_t		angles;			// Model angles
+	vec3_t		avelocity;		// angle velocity (degrees per second)
+	vec3_t		punchangle;		// auto-decaying view angle adjustment
+	vec3_t		v_angle;		// Viewing angle (player only)
+
+	// For parametric entities
+	vec3_t		endpos;
+	vec3_t		startpos;
+	float		impacttime;
+	float		starttime;
+
+	int			fixangle;		// 0:nothing, 1:force view angles, 2:add avelocity
+	float		idealpitch;
+	float		pitch_speed;
+	float		ideal_yaw;
+	float		yaw_speed;
+
+	int			modelindex;
+	string_t	model;
+
+	int			viewmodel;		// player's viewmodel
+	int			weaponmodel;	// what other players see
+	
+	vec3_t		absmin;		// BB max translated to world coord
+	vec3_t		absmax;		// BB max translated to world coord
+	vec3_t		mins;		// local BB min
+	vec3_t		maxs;		// local BB max
+	vec3_t		size;		// maxs - mins
+
+	float		ltime;
+	float		nextthink;
+
+	int			movetype;
+	int			solid;
+
+	int			skin;			
+	int			body;			// sub-model selection for studiomodels
+	int 		effects;
+	
+	float		gravity;		// % of "normal" gravity
+	float		friction;		// inverse elasticity of MOVETYPE_BOUNCE
+	
+	int			light_level;
+
+	int			sequence;		// animation sequence
+	int			gaitsequence;	// movement animation sequence for player (0 for none)
+	float		frame;			// % playback position in animation sequences (0..255)
+	float		animtime;		// world time when frame was set
+	float		framerate;		// animation playback rate (-8x to 8x)
+	byte		controller[4];	// bone controller setting (0..255)
+	byte		blending[2];	// blending amount between sub-sequences (0..255)
+
+	float		scale;			// sprite rendering scale (0..255)
+
+	int			rendermode;
+	float		renderamt;
+	vec3_t		rendercolor;
+	int			renderfx;
+
+	float		health;
+	float		frags;
+	int			weapons;  // bit mask for available weapons
+	float		takedamage;
+
+	int			deadflag;
+	vec3_t		view_ofs;	// eye position
+
+	int			button;
+	int			impulse;
+
+	edict_t		*chain;			// Entity pointer when linked into a linked list
+	edict_t		*dmg_inflictor;
+	edict_t		*enemy;
+	edict_t		*aiment;		// entity pointer when MOVETYPE_FOLLOW
+	edict_t		*owner;
+	edict_t		*groundentity;
+
+	int			spawnflags;
+	int			flags;
+	
+	int			colormap;		// lowbyte topcolor, highbyte bottomcolor
+	int			team;
+
+	float		max_health;
+	float		teleport_time;
+	float		armortype;
+	float		armorvalue;
+	int			waterlevel;
+	int			watertype;
+	
+	string_t	target;
+	string_t	targetname;
+	string_t	netname;
+	string_t	message;
+
+	float		dmg_take;
+	float		dmg_save;
+	float		dmg;
+	float		dmgtime;
+	
+	string_t	noise;
+	string_t	noise1;
+	string_t	noise2;
+	string_t	noise3;
+	
+	float		speed;
+	float		air_finished;
+	float		pain_finished;
+	float		radsuit_finished;
+	
+	edict_t		*pContainingEntity;
+
+	int			playerclass;
+	float		maxspeed;
+
+	float		fov;
+	int			weaponanim;
+
+	int			pushmsec;
+
+	int			bInDuck;
+	int			flTimeStepSound;
+	int			flSwimTime;
+	int			flDuckTime;
+	int			iStepLeft;
+	float		flFallVelocity;
+
+	int			gamestate;
+
+	int			oldbuttons;
+
+	int			groupinfo;
+
+	// For mods
+	int			iuser1;
+	int			iuser2;
+	int			iuser3;
+	int			iuser4;
+	float		fuser1;
+	float		fuser2;
+	float		fuser3;
+	float		fuser4;
+	vec3_t		vuser1;
+	vec3_t		vuser2;
+	vec3_t		vuser3;
+	vec3_t		vuser4;
+	edict_t		*euser1;
+	edict_t		*euser2;
+	edict_t		*euser3;
+	edict_t		*euser4;
+} entvars_t;
+
+
+#endif // PROGDEFS_H
diff --git a/sdk/hlsdk/engine/progs.h b/sdk/hlsdk/engine/progs.h
new file mode 100644
index 0000000..fe4796e
--- /dev/null
+++ b/sdk/hlsdk/engine/progs.h
@@ -0,0 +1,82 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef PROGS_H
+#define PROGS_H
+
+#include "progdefs.h"
+
+// 16 simultaneous events, max
+#define MAX_EVENT_QUEUE 64
+
+#define DEFAULT_EVENT_RESENDS 1
+
+#include "event_flags.h"
+
+typedef struct event_info_s event_info_t;
+
+#include "event_args.h"
+
+struct event_info_s
+{
+	unsigned short index;			  // 0 implies not in use
+
+	short packet_index;      // Use data from state info for entity in delta_packet .  -1 implies separate info based on event
+	                         // parameter signature
+	short entity_index;      // The edict this event is associated with
+
+	float fire_time;        // if non-zero, the time when the event should be fired ( fixed up on the client )
+	
+	event_args_t args;
+
+// CLIENT ONLY	
+	int	  flags;			// Reliable or not, etc.
+
+};
+
+typedef struct event_state_s event_state_t;
+
+struct event_state_s
+{
+	struct event_info_s ei[ MAX_EVENT_QUEUE ];
+};
+
+#if !defined( ENTITY_STATEH )
+#include "entity_state.h"
+#endif
+
+#if !defined( EDICT_H )
+#include "edict.h"
+#endif
+
+#define	STRUCT_FROM_LINK(l,t,m) ((t *)((byte *)l - (int)&(((t *)0)->m)))
+#define	EDICT_FROM_AREA(l) STRUCT_FROM_LINK(l,edict_t,area)
+
+//============================================================================
+
+extern	char			*pr_strings;
+extern	globalvars_t	gGlobalVariables;
+
+//============================================================================
+
+edict_t		*ED_Alloc (void);
+void		ED_Free (edict_t *ed);
+void		ED_LoadFromFile (char *data);
+
+edict_t		*EDICT_NUM(int n);
+int			NUM_FOR_EDICT(const edict_t *e);
+
+#define PROG_TO_EDICT(e) ((edict_t *)((byte *)sv.edicts + e))
+
+#endif // PROGS_H
diff --git a/sdk/hlsdk/engine/shake.h b/sdk/hlsdk/engine/shake.h
new file mode 100644
index 0000000..a18ddc2
--- /dev/null
+++ b/sdk/hlsdk/engine/shake.h
@@ -0,0 +1,55 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef SHAKE_H
+#define SHAKE_H
+
+// Screen / View effects
+
+// screen shake
+extern int gmsgShake;
+
+// This structure is sent over the net to describe a screen shake event
+typedef struct
+{
+	unsigned short	amplitude;		// FIXED 4.12 amount of shake
+	unsigned short 	duration;		// FIXED 4.12 seconds duration
+	unsigned short	frequency;		// FIXED 8.8 noise frequency (low frequency is a jerk,high frequency is a rumble)
+} ScreenShake;
+
+extern void V_ApplyShake( float *origin, float *angles, float factor );
+extern void V_CalcShake( void );
+extern int V_ScreenShake( const char *pszName, int iSize, void *pbuf );
+extern int V_ScreenFade( const char *pszName, int iSize, void *pbuf );
+
+
+// Fade in/out
+extern int gmsgFade;
+
+#define FFADE_IN			0x0000		// Just here so we don't pass 0 into the function
+#define FFADE_OUT			0x0001		// Fade out (not in)
+#define FFADE_MODULATE		0x0002		// Modulate (don't blend)
+#define FFADE_STAYOUT		0x0004		// ignores the duration, stays faded out until new ScreenFade message received
+
+// This structure is sent over the net to describe a screen fade event
+typedef struct
+{
+	unsigned short 	duration;		// FIXED 4.12 seconds duration
+	unsigned short 	holdTime;		// FIXED 4.12 seconds duration until reset (fade & hold)
+	short			fadeFlags;		// flags
+	byte			r, g, b, a;		// fade to color ( max alpha )
+} ScreenFade;
+
+#endif		// SHAKE_H
+
diff --git a/sdk/hlsdk/engine/studio.h b/sdk/hlsdk/engine/studio.h
new file mode 100644
index 0000000..ec98f2d
--- /dev/null
+++ b/sdk/hlsdk/engine/studio.h
@@ -0,0 +1,362 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+
+
+
+
+#ifndef _STUDIO_H_
+#define _STUDIO_H_
+
+/*
+==============================================================================
+
+STUDIO MODELS
+
+Studio models are position independent, so the cache manager can move them.
+==============================================================================
+*/
+
+
+#define MAXSTUDIOTRIANGLES	20000	// TODO: tune this
+#define MAXSTUDIOVERTS		2048	// TODO: tune this
+#define MAXSTUDIOSEQUENCES	256		// total animation sequences
+#define MAXSTUDIOSKINS		100		// total textures
+#define MAXSTUDIOSRCBONES	512		// bones allowed at source movement
+#define MAXSTUDIOBONES		128		// total bones actually used
+#define MAXSTUDIOMODELS		32		// sub-models per model
+#define MAXSTUDIOBODYPARTS	32
+#define MAXSTUDIOGROUPS		16
+#define MAXSTUDIOANIMATIONS	512		// per sequence
+#define MAXSTUDIOMESHES		256
+#define MAXSTUDIOEVENTS		1024
+#define MAXSTUDIOPIVOTS		256
+#define MAXSTUDIOCONTROLLERS 8
+
+typedef struct 
+{
+	int					id;
+	int					version;
+
+	char				name[64];
+	int					length;
+
+	vec3_t				eyeposition;	// ideal eye position
+	vec3_t				min;			// ideal movement hull size
+	vec3_t				max;			
+
+	vec3_t				bbmin;			// clipping bounding box
+	vec3_t				bbmax;		
+
+	int					flags;
+
+	int					numbones;			// bones
+	int					boneindex;
+
+	int					numbonecontrollers;		// bone controllers
+	int					bonecontrollerindex;
+
+	int					numhitboxes;			// complex bounding boxes
+	int					hitboxindex;			
+	
+	int					numseq;				// animation sequences
+	int					seqindex;
+
+	int					numseqgroups;		// demand loaded sequences
+	int					seqgroupindex;
+
+	int					numtextures;		// raw textures
+	int					textureindex;
+	int					texturedataindex;
+
+	int					numskinref;			// replaceable textures
+	int					numskinfamilies;
+	int					skinindex;
+
+	int					numbodyparts;		
+	int					bodypartindex;
+
+	int					numattachments;		// queryable attachable points
+	int					attachmentindex;
+
+	int					soundtable;
+	int					soundindex;
+	int					soundgroups;
+	int					soundgroupindex;
+
+	int					numtransitions;		// animation node to animation node transition graph
+	int					transitionindex;
+} studiohdr_t;
+
+// header for demand loaded sequence group data
+typedef struct 
+{
+	int					id;
+	int					version;
+
+	char				name[64];
+	int					length;
+} studioseqhdr_t;
+
+// bones
+typedef struct 
+{
+	char				name[32];	// bone name for symbolic links
+	int		 			parent;		// parent bone
+	int					flags;		// ??
+	int					bonecontroller[6];	// bone controller index, -1 == none
+	float				value[6];	// default DoF values
+	float				scale[6];   // scale for delta DoF values
+} mstudiobone_t;
+
+
+// bone controllers
+typedef struct 
+{
+	int					bone;	// -1 == 0
+	int					type;	// X, Y, Z, XR, YR, ZR, M
+	float				start;
+	float				end;
+	int					rest;	// byte index value at rest
+	int					index;	// 0-3 user set controller, 4 mouth
+} mstudiobonecontroller_t;
+
+// intersection boxes
+typedef struct
+{
+	int					bone;
+	int					group;			// intersection group
+	vec3_t				bbmin;		// bounding box
+	vec3_t				bbmax;		
+} mstudiobbox_t;
+
+#if !defined( CACHE_USER ) && !defined( QUAKEDEF_H )
+#define CACHE_USER
+typedef struct cache_user_s
+{
+	void *data;
+} cache_user_t;
+#endif
+
+// demand loaded sequence groups
+typedef struct
+{
+	char				label[32];	// textual name
+	char				name[64];	// file name
+	cache_user_t		cache;		// cache index pointer
+	int					data;		// hack for group 0
+} mstudioseqgroup_t;
+
+// sequence descriptions
+typedef struct
+{
+	char				label[32];	// sequence label
+
+	float				fps;		// frames per second	
+	int					flags;		// looping/non-looping flags
+
+	int					activity;
+	int					actweight;
+
+	int					numevents;
+	int					eventindex;
+
+	int					numframes;	// number of frames per sequence
+
+	int					numpivots;	// number of foot pivots
+	int					pivotindex;
+
+	int					motiontype;	
+	int					motionbone;
+	vec3_t				linearmovement;
+	int					automoveposindex;
+	int					automoveangleindex;
+
+	vec3_t				bbmin;		// per sequence bounding box
+	vec3_t				bbmax;		
+
+	int					numblends;
+	int					animindex;		// mstudioanim_t pointer relative to start of sequence group data
+										// [blend][bone][X, Y, Z, XR, YR, ZR]
+
+	int					blendtype[2];	// X, Y, Z, XR, YR, ZR
+	float				blendstart[2];	// starting value
+	float				blendend[2];	// ending value
+	int					blendparent;
+
+	int					seqgroup;		// sequence group for demand loading
+
+	int					entrynode;		// transition node at entry
+	int					exitnode;		// transition node at exit
+	int					nodeflags;		// transition rules
+	
+	int					nextseq;		// auto advancing sequences
+} mstudioseqdesc_t;
+
+// events
+#include "studio_event.h"
+/*
+typedef struct 
+{
+	int 				frame;
+	int					event;
+	int					type;
+	char				options[64];
+} mstudioevent_t;
+*/
+
+// pivots
+typedef struct 
+{
+	vec3_t				org;	// pivot point
+	int					start;
+	int					end;
+} mstudiopivot_t;
+
+// attachment
+typedef struct 
+{
+	char				name[32];
+	int					type;
+	int					bone;
+	vec3_t				org;	// attachment point
+	vec3_t				vectors[3];
+} mstudioattachment_t;
+
+typedef struct
+{
+	unsigned short	offset[6];
+} mstudioanim_t;
+
+// animation frames
+typedef union 
+{
+	struct {
+		byte	valid;
+		byte	total;
+	} num;
+	short		value;
+} mstudioanimvalue_t;
+
+
+
+// body part index
+typedef struct
+{
+	char				name[64];
+	int					nummodels;
+	int					base;
+	int					modelindex; // index into models array
+} mstudiobodyparts_t;
+
+
+
+// skin info
+typedef struct
+{
+	char					name[64];
+	int						flags;
+	int						width;
+	int						height;
+	int						index;
+} mstudiotexture_t;
+
+
+// skin families
+// short	index[skinfamilies][skinref]
+
+// studio models
+typedef struct
+{
+	char				name[64];
+
+	int					type;
+
+	float				boundingradius;
+
+	int					nummesh;
+	int					meshindex;
+
+	int					numverts;		// number of unique vertices
+	int					vertinfoindex;	// vertex bone info
+	int					vertindex;		// vertex vec3_t
+	int					numnorms;		// number of unique surface normals
+	int					norminfoindex;	// normal bone info
+	int					normindex;		// normal vec3_t
+
+	int					numgroups;		// deformation groups
+	int					groupindex;
+} mstudiomodel_t;
+
+
+// vec3_t	boundingbox[model][bone][2];	// complex intersection info
+
+
+// meshes
+typedef struct 
+{
+	int					numtris;
+	int					triindex;
+	int					skinref;
+	int					numnorms;		// per mesh normals
+	int					normindex;		// normal vec3_t
+} mstudiomesh_t;
+
+// triangles
+#if 0
+typedef struct 
+{
+	short				vertindex;		// index into vertex array
+	short				normindex;		// index into normal array
+	short				s,t;			// s,t position on skin
+} mstudiotrivert_t;
+#endif
+
+// lighting options
+#define STUDIO_NF_FLATSHADE		0x0001
+#define STUDIO_NF_CHROME		0x0002
+#define STUDIO_NF_FULLBRIGHT	0x0004
+
+// motion flags
+#define STUDIO_X		0x0001
+#define STUDIO_Y		0x0002	
+#define STUDIO_Z		0x0004
+#define STUDIO_XR		0x0008
+#define STUDIO_YR		0x0010
+#define STUDIO_ZR		0x0020
+#define STUDIO_LX		0x0040
+#define STUDIO_LY		0x0080
+#define STUDIO_LZ		0x0100
+#define STUDIO_AX		0x0200
+#define STUDIO_AY		0x0400
+#define STUDIO_AZ		0x0800
+#define STUDIO_AXR		0x1000
+#define STUDIO_AYR		0x2000
+#define STUDIO_AZR		0x4000
+#define STUDIO_TYPES	0x7FFF
+#define STUDIO_RLOOP	0x8000	// controller that wraps shortest distance
+
+// sequence flags
+#define STUDIO_LOOPING	0x0001
+
+// bone flags
+#define STUDIO_HAS_NORMALS	0x0001
+#define STUDIO_HAS_VERTICES 0x0002
+#define STUDIO_HAS_BBOX		0x0004
+#define STUDIO_HAS_CHROME	0x0008	// if any of the textures have chrome on them
+
+#define RAD_TO_STUDIO		(32768.0/M_PI)
+#define STUDIO_TO_RAD		(M_PI/32768.0)
+
+#endif
diff --git a/sdk/hlsdk/pm_shared/pm_debug.h b/sdk/hlsdk/pm_shared/pm_debug.h
new file mode 100644
index 0000000..a506d37
--- /dev/null
+++ b/sdk/hlsdk/pm_shared/pm_debug.h
@@ -0,0 +1,28 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#ifndef PM_DEBUG_H
+#define PM_DEBUG_H
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+void PM_ViewEntity( void );
+void PM_DrawBBox(vec3_t mins, vec3_t maxs, vec3_t origin, int pcolor, float life);
+void PM_ParticleLine(vec3_t start, vec3_t end, int pcolor, float life, float vert);
+void PM_ShowClipBox( void );
+
+#endif // PMOVEDBG_H
diff --git a/sdk/hlsdk/pm_shared/pm_defs.h b/sdk/hlsdk/pm_shared/pm_defs.h
new file mode 100644
index 0000000..dba6d4e
--- /dev/null
+++ b/sdk/hlsdk/pm_shared/pm_defs.h
@@ -0,0 +1,226 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+// pm_defs.h
+#if !defined( PM_DEFSH )
+#define PM_DEFSH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#define	MAX_PHYSENTS 600 		  // Must have room for all entities in the world.
+#define MAX_MOVEENTS 64
+#define	MAX_CLIP_PLANES	5
+
+#define PM_NORMAL			0x00000000
+#define PM_STUDIO_IGNORE	0x00000001		// Skip studio models
+#define PM_STUDIO_BOX		0x00000002		// Use boxes for non-complex studio models (even in traceline)
+#define PM_GLASS_IGNORE		0x00000004		// Ignore entities with non-normal rendermode
+#define PM_WORLD_ONLY		0x00000008		// Only trace against the world
+
+// Values for flags parameter of PM_TraceLine
+#define PM_TRACELINE_PHYSENTSONLY	0
+#define PM_TRACELINE_ANYVISIBLE		1
+
+
+#include "pm_info.h"
+
+// PM_PlayerTrace results.
+#include "pmtrace.h"
+
+#if !defined ( USERCMD_H )
+#include "usercmd.h"
+#endif
+
+// physent_t
+typedef struct physent_s
+{
+	char			name[32];             // Name of model, or "player" or "world".
+	int				player;
+	vec3_t			origin;               // Model's origin in world coordinates.
+	struct model_s	*model;		          // only for bsp models
+	struct model_s	*studiomodel;         // SOLID_BBOX, but studio clip intersections.
+	vec3_t			mins, maxs;	          // only for non-bsp models
+	int				info;		          // For client or server to use to identify (index into edicts or cl_entities)
+	vec3_t			angles;               // rotated entities need this info for hull testing to work.
+
+	int				solid;				  // Triggers and func_door type WATER brushes are SOLID_NOT
+	int				skin;                 // BSP Contents for such things like fun_door water brushes.
+	int				rendermode;			  // So we can ignore glass
+	
+	// Complex collision detection.
+	float			frame;
+	int				sequence;
+	byte			controller[4];
+	byte			blending[2];
+
+	int				movetype;
+	int				takedamage;
+	int				blooddecal;
+	int				team;
+	int				classnumber;
+
+	// For mods
+	int				iuser1;
+	int				iuser2;
+	int				iuser3;
+	int				iuser4;
+	float			fuser1;
+	float			fuser2;
+	float			fuser3;
+	float			fuser4;
+	vec3_t			vuser1;
+	vec3_t			vuser2;
+	vec3_t			vuser3;
+	vec3_t			vuser4;
+} physent_t;
+
+
+typedef struct playermove_s
+{
+	int				player_index;  // So we don't try to run the PM_CheckStuck nudging too quickly.
+	qboolean		server;        // For debugging, are we running physics code on server side?
+
+	qboolean		multiplayer;   // 1 == multiplayer server
+	float			time;          // realtime on host, for reckoning duck timing
+	float			frametime;	   // Duration of this frame
+
+	vec3_t			forward, right, up; // Vectors for angles
+	// player state
+	vec3_t			origin;        // Movement origin.
+	vec3_t			angles;        // Movement view angles.
+	vec3_t			oldangles;     // Angles before movement view angles were looked at.
+	vec3_t			velocity;      // Current movement direction.
+	vec3_t			movedir;       // For waterjumping, a forced forward velocity so we can fly over lip of ledge.
+	vec3_t			basevelocity;  // Velocity of the conveyor we are standing, e.g.
+	
+	// For ducking/dead
+	vec3_t			view_ofs;      // Our eye position.
+	float			flDuckTime;    // Time we started duck
+	qboolean		bInDuck;       // In process of ducking or ducked already?
+	
+	// For walking/falling
+	int				flTimeStepSound;  // Next time we can play a step sound
+	int				iStepLeft;
+
+	float			flFallVelocity;
+	vec3_t			punchangle;
+
+	float			flSwimTime;
+
+	float			flNextPrimaryAttack;
+
+	int				effects;		// MUZZLE FLASH, e.g.
+
+	int				flags;         // FL_ONGROUND, FL_DUCKING, etc.
+	int				usehull;       // 0 = regular player hull, 1 = ducked player hull, 2 = point hull
+	float			gravity;       // Our current gravity and friction.
+	float			friction;
+	int				oldbuttons;    // Buttons last usercmd
+	float			waterjumptime; // Amount of time left in jumping out of water cycle.
+	qboolean		dead;          // Are we a dead player?
+	int				deadflag;
+	int				spectator;     // Should we use spectator physics model?
+	int				movetype;      // Our movement type, NOCLIP, WALK, FLY
+
+	int				onground;
+	int				waterlevel;
+	int				watertype;
+	int				oldwaterlevel;
+
+	char			sztexturename[256];
+	char			chtexturetype;
+
+	float			maxspeed;
+	float			clientmaxspeed; // Player specific maxspeed
+
+	// For mods
+	int				iuser1;
+	int				iuser2;
+	int				iuser3;
+	int				iuser4;
+	float			fuser1;
+	float			fuser2;
+	float			fuser3;
+	float			fuser4;
+	vec3_t			vuser1;
+	vec3_t			vuser2;
+	vec3_t			vuser3;
+	vec3_t			vuser4;
+	// world state
+	// Number of entities to clip against.
+	int				numphysent;    
+	physent_t		physents[MAX_PHYSENTS];
+	// Number of momvement entities (ladders)
+	int				nummoveent;
+	// just a list of ladders
+	physent_t		moveents[MAX_MOVEENTS];	
+
+	// All things being rendered, for tracing against things you don't actually collide with
+	int				numvisent;
+	physent_t		visents[ MAX_PHYSENTS ];
+
+	// input to run through physics.
+	usercmd_t		cmd;
+
+	// Trace results for objects we collided with.
+	int				numtouch;
+	pmtrace_t		touchindex[MAX_PHYSENTS];
+
+	char			physinfo[ MAX_PHYSINFO_STRING ]; // Physics info string
+
+	struct movevars_s *movevars;
+	vec3_t player_mins[ 4 ];
+	vec3_t player_maxs[ 4 ];
+	
+	// Common functions
+	const char		*(*PM_Info_ValueForKey) ( const char *s, const char *key );
+	void			(*PM_Particle)( float *origin, int color, float life, int zpos, int zvel);
+	int				(*PM_TestPlayerPosition) (float *pos, pmtrace_t *ptrace );
+	void			(*Con_NPrintf)( int idx, char *fmt, ... );
+	void			(*Con_DPrintf)( char *fmt, ... );
+	void			(*Con_Printf)( char *fmt, ... );
+	double			(*Sys_FloatTime)( void );
+	void			(*PM_StuckTouch)( int hitent, pmtrace_t *ptraceresult );
+	int				(*PM_PointContents) (float *p, int *truecontents /*filled in if this is non-null*/ );
+	int				(*PM_TruePointContents) (float *p);
+	int				(*PM_HullPointContents) ( struct hull_s *hull, int num, float *p);   
+	pmtrace_t		(*PM_PlayerTrace) (float *start, float *end, int traceFlags, int ignore_pe );
+	struct pmtrace_s *(*PM_TraceLine)( float *start, float *end, int flags, int usehulll, int ignore_pe );
+	long			(*RandomLong)( long lLow, long lHigh );
+	float			(*RandomFloat)( float flLow, float flHigh );
+	int				(*PM_GetModelType)( struct model_s *mod );
+	void			(*PM_GetModelBounds)( struct model_s *mod, float *mins, float *maxs );
+	void			*(*PM_HullForBsp)( physent_t *pe, float *offset );
+	float			(*PM_TraceModel)( physent_t *pEnt, float *start, float *end, trace_t *trace );
+	int				(*COM_FileSize)(char *filename);
+	byte			*(*COM_LoadFile) (char *path, int usehunk, int *pLength);
+	void			(*COM_FreeFile) ( void *buffer );
+	char			*(*memfgets)( byte *pMemFile, int fileSize, int *pFilePos, char *pBuffer, int bufferSize );
+
+	// Functions
+	// Run functions for this frame?
+	qboolean		runfuncs;      
+	void			(*PM_PlaySound) ( int channel, const char *sample, float volume, float attenuation, int fFlags, int pitch );
+	const char		*(*PM_TraceTexture) ( int ground, float *vstart, float *vend );
+	void			(*PM_PlaybackEventFull) ( int flags, int clientindex, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 );
+	
+	pmtrace_t		(*PM_PlayerTraceEx) (float *start, float *end, int traceFlags, int (*pfnIgnore)( physent_t *pe ) );
+	int				(*PM_TestPlayerPositionEx) (float *pos, pmtrace_t *ptrace, int (*pfnIgnore)( physent_t *pe ) );
+	struct pmtrace_s *(*PM_TraceLineEx)( float *start, float *end, int flags, int usehulll, int (*pfnIgnore)( physent_t *pe ) );
+} playermove_t;
+
+#endif
diff --git a/sdk/hlsdk/pm_shared/pm_info.h b/sdk/hlsdk/pm_shared/pm_info.h
new file mode 100644
index 0000000..fa3cc19
--- /dev/null
+++ b/sdk/hlsdk/pm_shared/pm_info.h
@@ -0,0 +1,26 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+// Physics info string definition
+#if !defined( PM_INFOH )
+#define PM_INFOH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#define MAX_PHYSINFO_STRING 256
+
+#endif // PM_INFOH
diff --git a/sdk/hlsdk/pm_shared/pm_materials.h b/sdk/hlsdk/pm_shared/pm_materials.h
new file mode 100644
index 0000000..4140781
--- /dev/null
+++ b/sdk/hlsdk/pm_shared/pm_materials.h
@@ -0,0 +1,37 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+#if !defined( PM_MATERIALSH )
+#define PM_MATERIALSH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+#define CBTEXTURENAMEMAX	13			// only load first n chars of name
+
+#define CHAR_TEX_CONCRETE	'C'			// texture types
+#define CHAR_TEX_METAL		'M'
+#define CHAR_TEX_DIRT		'D'
+#define CHAR_TEX_VENT		'V'
+#define CHAR_TEX_GRATE		'G'
+#define CHAR_TEX_TILE		'T'
+#define CHAR_TEX_SLOSH		'S'
+#define CHAR_TEX_WOOD		'W'
+#define CHAR_TEX_COMPUTER	'P'
+#define CHAR_TEX_GLASS		'Y'
+#define CHAR_TEX_FLESH		'F'
+
+#endif // !PM_MATERIALSH
diff --git a/sdk/hlsdk/pm_shared/pm_movevars.h b/sdk/hlsdk/pm_shared/pm_movevars.h
new file mode 100644
index 0000000..66c99ee
--- /dev/null
+++ b/sdk/hlsdk/pm_shared/pm_movevars.h
@@ -0,0 +1,47 @@
+//========= Copyright � 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+// pm_movevars.h
+#if !defined( PM_MOVEVARSH )
+#define PM_MOVEVARSH
+
+// movevars_t                  // Physics variables.
+typedef struct movevars_s movevars_t;
+
+struct movevars_s
+{
+	float	gravity;           // Gravity for map
+	float	stopspeed;         // Deceleration when not moving
+	float	maxspeed;          // Max allowed speed
+	float	spectatormaxspeed;
+	float	accelerate;        // Acceleration factor
+	float	airaccelerate;     // Same for when in open air
+	float	wateraccelerate;   // Same for when in water
+	float	friction;          
+	float   edgefriction;	   // Extra friction near dropofs 
+	float	waterfriction;     // Less in water
+	float	entgravity;        // 1.0
+	float   bounce;            // Wall bounce value. 1.0
+	float   stepsize;          // sv_stepsize;
+	float   maxvelocity;       // maximum server velocity.
+	float	zmax;			   // Max z-buffer range (for GL)
+	float	waveHeight;		   // Water wave height (for GL)
+	qboolean footsteps;        // Play footstep sounds
+	char	skyName[32];	   // Name of the sky map
+	float	rollangle;
+	float	rollspeed;
+	float	skycolor_r;			// Sky color
+	float	skycolor_g;			// 
+	float	skycolor_b;			//
+	float	skyvec_x;			// Sky vector
+	float	skyvec_y;			// 
+	float	skyvec_z;			// 
+};
+
+extern movevars_t movevars;
+
+#endif
diff --git a/sdk/hlsdk/pm_shared/pm_shared.h b/sdk/hlsdk/pm_shared/pm_shared.h
new file mode 100644
index 0000000..153c539
--- /dev/null
+++ b/sdk/hlsdk/pm_shared/pm_shared.h
@@ -0,0 +1,40 @@
+/***
+*
+*	Copyright (c) 1996-2002, 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.
+*
+****/
+
+//
+// pm_shared.h
+//
+#if !defined( PM_SHAREDH )
+#define PM_SHAREDH
+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma once
+#endif /* not __MINGW32__ */
+#endif
+
+void PM_Init( struct playermove_s *ppmove );
+void PM_Move ( struct playermove_s *ppmove, int server );
+char PM_FindTextureType( char *name );
+
+// Spectator Movement modes (stored in pev->iuser1, so the physics code can get at them)
+#define OBS_NONE				0
+#define OBS_CHASE_LOCKED		1
+#define OBS_CHASE_FREE			2
+#define OBS_ROAMING				3		
+#define OBS_IN_EYE				4
+#define OBS_MAP_FREE			5
+#define OBS_MAP_CHASE			6
+
+#endif
diff --git a/sdk/metamod/api_info.h b/sdk/metamod/api_info.h
new file mode 100644
index 0000000..86711fd
--- /dev/null
+++ b/sdk/metamod/api_info.h
@@ -0,0 +1,296 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// api_info.h - structures to store info about api routines
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 API_INFO_H
+#define API_INFO_H
+
+#include "types_meta.h"			// mBOOL
+
+
+#define P_PRE 0		// plugin function called before gamedll
+#define P_POST 1	// plugin function called after gamedll
+
+
+typedef struct api_info_s {
+	mBOOL trace;		// if true, log info about this function
+	int loglevel;		// level at which to log info about this function
+	char *name;			// string representation of function name
+} api_info_t;
+
+
+// DLL api functions
+typedef struct dllapi_info_s {
+	api_info_t pfnGameInit;
+	api_info_t pfnSpawn;
+	api_info_t pfnThink;
+	api_info_t pfnUse;
+	api_info_t pfnTouch;
+	api_info_t pfnBlocked;
+	api_info_t pfnKeyValue;
+	api_info_t pfnSave;
+	api_info_t pfnRestore;
+	api_info_t pfnSetAbsBox;
+	api_info_t pfnSaveWriteFields;
+	api_info_t pfnSaveReadFields;
+	api_info_t pfnSaveGlobalState;
+	api_info_t pfnRestoreGlobalState;
+	api_info_t pfnResetGlobalState;
+	api_info_t pfnClientConnect;
+	api_info_t pfnClientDisconnect;
+	api_info_t pfnClientKill;
+	api_info_t pfnClientPutInServer;
+	api_info_t pfnClientCommand;
+	api_info_t pfnClientUserInfoChanged;
+	api_info_t pfnServerActivate;
+	api_info_t pfnServerDeactivate;
+	api_info_t pfnPlayerPreThink;
+	api_info_t pfnPlayerPostThink;
+	api_info_t pfnStartFrame;
+	api_info_t pfnParmsNewLevel;
+	api_info_t pfnParmsChangeLevel;
+	api_info_t pfnGetGameDescription;
+	api_info_t pfnPlayerCustomization;
+	api_info_t pfnSpectatorConnect;
+	api_info_t pfnSpectatorDisconnect;
+	api_info_t pfnSpectatorThink;
+	api_info_t pfnSys_Error;
+	api_info_t pfnPM_Move;
+	api_info_t pfnPM_Init;
+	api_info_t pfnPM_FindTextureType;
+	api_info_t pfnSetupVisibility;
+	api_info_t pfnUpdateClientData;
+	api_info_t pfnAddToFullPack;
+	api_info_t pfnCreateBaseline;
+	api_info_t pfnRegisterEncoders;
+	api_info_t pfnGetWeaponData;
+	api_info_t pfnCmdStart;
+	api_info_t pfnCmdEnd;
+	api_info_t pfnConnectionlessPacket;
+	api_info_t pfnGetHullBounds;
+	api_info_t pfnCreateInstancedBaselines;
+	api_info_t pfnInconsistentFile;
+	api_info_t pfnAllowLagCompensation;
+	api_info_t END;
+} dllapi_info_t;
+
+
+// "New" api functions
+typedef struct newapi_info_s {
+	api_info_t pfnOnFreeEntPrivateData;
+	api_info_t pfnGameShutdown;
+	api_info_t pfnShouldCollide;
+	// Added 2005/08/11 (no SDK update)
+	api_info_t pfnCvarValue;
+	// Added 2005/11/22 (no SDK update)
+	api_info_t pfnCvarValue2;
+	api_info_t END;
+} newapi_info_t;
+
+
+// Engine functions
+typedef struct engine_info_s {
+	api_info_t pfnPrecacheModel;
+	api_info_t pfnPrecacheSound;
+	api_info_t pfnSetModel;
+	api_info_t pfnModelIndex;
+	api_info_t pfnModelFrames;
+	api_info_t pfnSetSize;
+	api_info_t pfnChangeLevel;
+	api_info_t pfnGetSpawnParms;
+	api_info_t pfnSaveSpawnParms;
+	api_info_t pfnVecToYaw;
+	api_info_t pfnVecToAngles;
+	api_info_t pfnMoveToOrigin;
+	api_info_t pfnChangeYaw;
+	api_info_t pfnChangePitch;
+	api_info_t pfnFindEntityByString;
+	api_info_t pfnGetEntityIllum;
+	api_info_t pfnFindEntityInSphere;
+	api_info_t pfnFindClientInPVS;
+	api_info_t pfnEntitiesInPVS;
+	api_info_t pfnMakeVectors;
+	api_info_t pfnAngleVectors;
+	api_info_t pfnCreateEntity;
+	api_info_t pfnRemoveEntity;
+	api_info_t pfnCreateNamedEntity;
+	api_info_t pfnMakeStatic;
+	api_info_t pfnEntIsOnFloor;
+	api_info_t pfnDropToFloor;
+	api_info_t pfnWalkMove;
+	api_info_t pfnSetOrigin;
+	api_info_t pfnEmitSound;
+	api_info_t pfnEmitAmbientSound;
+	api_info_t pfnTraceLine;
+	api_info_t pfnTraceToss;
+	api_info_t pfnTraceMonsterHull;
+	api_info_t pfnTraceHull;
+	api_info_t pfnTraceModel;
+	api_info_t pfnTraceTexture;
+	api_info_t pfnTraceSphere;
+	api_info_t pfnGetAimVector;
+	api_info_t pfnServerCommand;
+	api_info_t pfnServerExecute;
+	api_info_t pfnClientCommand;
+	api_info_t pfnParticleEffect;
+	api_info_t pfnLightStyle;
+	api_info_t pfnDecalIndex;
+	api_info_t pfnPointContents;
+	api_info_t pfnMessageBegin;
+	api_info_t pfnMessageEnd;
+	api_info_t pfnWriteByte;
+	api_info_t pfnWriteChar;
+	api_info_t pfnWriteShort;
+	api_info_t pfnWriteLong;
+	api_info_t pfnWriteAngle;
+	api_info_t pfnWriteCoord;
+	api_info_t pfnWriteString;
+	api_info_t pfnWriteEntity;
+	api_info_t pfnCVarRegister;
+	api_info_t pfnCVarGetFloat;
+	api_info_t pfnCVarGetString;
+	api_info_t pfnCVarSetFloat;
+	api_info_t pfnCVarSetString;
+	api_info_t pfnAlertMessage;
+	api_info_t pfnEngineFprintf;
+	api_info_t pfnPvAllocEntPrivateData;
+	api_info_t pfnPvEntPrivateData;
+	api_info_t pfnFreeEntPrivateData;
+	api_info_t pfnSzFromIndex;
+	api_info_t pfnAllocString;
+	api_info_t pfnGetVarsOfEnt;
+	api_info_t pfnPEntityOfEntOffset;
+	api_info_t pfnEntOffsetOfPEntity;
+	api_info_t pfnIndexOfEdict;
+	api_info_t pfnPEntityOfEntIndex;
+	api_info_t pfnFindEntityByVars;
+	api_info_t pfnGetModelPtr;
+	api_info_t pfnRegUserMsg;
+	api_info_t pfnAnimationAutomove;
+	api_info_t pfnGetBonePosition;
+	api_info_t pfnFunctionFromName;
+	api_info_t pfnNameForFunction;
+	api_info_t pfnClientPrintf;
+	api_info_t pfnServerPrint;
+	api_info_t pfnCmd_Args;
+	api_info_t pfnCmd_Argv;
+	api_info_t pfnCmd_Argc;
+	api_info_t pfnGetAttachment;
+	api_info_t pfnCRC32_Init;
+	api_info_t pfnCRC32_ProcessBuffer;
+	api_info_t pfnCRC32_ProcessByte;
+	api_info_t pfnCRC32_Final;
+	api_info_t pfnRandomLong;
+	api_info_t pfnRandomFloat;
+	api_info_t pfnSetView;
+	api_info_t pfnTime;
+	api_info_t pfnCrosshairAngle;
+	api_info_t pfnLoadFileForMe;
+	api_info_t pfnFreeFile;
+	api_info_t pfnEndSection;
+	api_info_t pfnCompareFileTime;
+	api_info_t pfnGetGameDir;
+	api_info_t pfnCvar_RegisterVariable;
+	api_info_t pfnFadeClientVolume;
+	api_info_t pfnSetClientMaxspeed;
+	api_info_t pfnCreateFakeClient;
+	api_info_t pfnRunPlayerMove;
+	api_info_t pfnNumberOfEntities;
+	api_info_t pfnGetInfoKeyBuffer;
+	api_info_t pfnInfoKeyValue;
+	api_info_t pfnSetKeyValue;
+	api_info_t pfnSetClientKeyValue;
+	api_info_t pfnIsMapValid;
+	api_info_t pfnStaticDecal;
+	api_info_t pfnPrecacheGeneric;
+	api_info_t pfnGetPlayerUserId;
+	api_info_t pfnBuildSoundMsg;
+	api_info_t pfnIsDedicatedServer;
+	api_info_t pfnCVarGetPointer;
+	api_info_t pfnGetPlayerWONId;
+	api_info_t pfnInfo_RemoveKey;
+	api_info_t pfnGetPhysicsKeyValue;
+	api_info_t pfnSetPhysicsKeyValue;
+	api_info_t pfnGetPhysicsInfoString;
+	api_info_t pfnPrecacheEvent;
+	api_info_t pfnPlaybackEvent;
+	api_info_t pfnSetFatPVS;
+	api_info_t pfnSetFatPAS;
+	api_info_t pfnCheckVisibility;
+	api_info_t pfnDeltaSetField;
+	api_info_t pfnDeltaUnsetField;
+	api_info_t pfnDeltaAddEncoder;
+	api_info_t pfnGetCurrentPlayer;
+	api_info_t pfnCanSkipPlayer;
+	api_info_t pfnDeltaFindField;
+	api_info_t pfnDeltaSetFieldByIndex;
+	api_info_t pfnDeltaUnsetFieldByIndex;
+	api_info_t pfnSetGroupMask;
+	api_info_t pfnCreateInstancedBaseline;
+	api_info_t pfnCvar_DirectSet;
+	api_info_t pfnForceUnmodified;
+	api_info_t pfnGetPlayerStats;
+	api_info_t pfnAddServerCommand;
+	// Added in SDK 2.2:
+	api_info_t pfnVoice_GetClientListening;
+	api_info_t pfnVoice_SetClientListening;
+	// Added for HL 1109 (no SDK update):
+	api_info_t pfnGetPlayerAuthId;
+	// Added 2003/11/10 (no SDK update):
+	api_info_t pfnSequenceGet;
+	api_info_t pfnSequencePickSentence;
+	api_info_t pfnGetFileSize;
+	api_info_t pfnGetApproxWavePlayLen;
+	api_info_t pfnIsCareerMatch;
+	api_info_t pfnGetLocalizedStringLength;
+	api_info_t pfnRegisterTutorMessageShown;
+	api_info_t pfnGetTimesTutorMessageShown;
+	api_info_t pfnProcessTutorMessageDecayBuffer;
+	api_info_t pfnConstructTutorMessageDecayBuffer;
+	api_info_t pfnResetTutorMessageDecayData;
+	// Added 2005/08/11 (no SDK update)
+	api_info_t pfnQueryClientCvarValue;
+	// Added 2005/11/22 (no SDK update)
+	api_info_t pfnQueryClientCvarValue2;
+	// end
+	api_info_t END;
+} engine_info_t;
+
+
+extern dllapi_info_t dllapi_info;
+extern newapi_info_t newapi_info;
+extern engine_info_t engine_info;
+
+#endif /* API_INFO_H */
diff --git a/sdk/metamod/commands_meta.h b/sdk/metamod/commands_meta.h
new file mode 100644
index 0000000..69aa0e9
--- /dev/null
+++ b/sdk/metamod/commands_meta.h
@@ -0,0 +1,81 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// commands_meta.h - prototypes for console commands
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 COMMANDS_META_H
+#define COMMANDS_META_H
+
+#include "types_meta.h"			// mBOOL
+
+// Flags to use for meta_cmd_doplug(), to operate on existing plugins; note
+// "load" operates on a non-existing plugin thus isn't included here.
+typedef enum {
+	PC_NULL = 0,
+	PC_PAUSE,		// pause the plugin
+	PC_UNPAUSE,		// unpause the plugin
+	PC_UNLOAD,		// unload the plugin
+	PC_RELOAD,		// unload the plugin and load it again
+	PC_RETRY,		// retry a failed operation (usually load/attach)
+	PC_INFO,		// show all info about the plugin
+	PC_CLEAR,		// remove a failed plugin from the list
+	PC_FORCE_UNLOAD,	// forcibly unload the plugin
+	PC_REQUIRE,		// require that this plugin is loaded/running
+} PLUG_CMD;
+
+void meta_register_cmdcvar();
+
+void svr_meta(void);
+
+void cmd_meta_usage(void);
+void cmd_meta_version(void);
+void cmd_meta_gpl(void);
+
+void cmd_meta_game(void);
+void cmd_meta_refresh(void);
+void cmd_meta_load(void);
+
+void cmd_meta_pluginlist(void);
+void cmd_meta_cmdlist(void);
+void cmd_meta_cvarlist(void);
+void cmd_meta_config(void);
+
+void cmd_doplug(PLUG_CMD pcmd);
+
+void client_meta(edict_t *pEntity);
+void client_meta_usage(edict_t *pEntity);
+void client_meta_version(edict_t *pEntity);
+void client_meta_pluginlist(edict_t *pEntity);
+
+#endif /* COMMANDS_META_H */
diff --git a/sdk/metamod/conf_meta.h b/sdk/metamod/conf_meta.h
new file mode 100644
index 0000000..d8dfbbb
--- /dev/null
+++ b/sdk/metamod/conf_meta.h
@@ -0,0 +1,96 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// conf_meta.h - configfile reading
+
+// Modeled after mutt/init.[ch].
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 CONF_META_H
+#define CONF_META_H
+
+#include "types_meta.h"		// mBOOL
+
+// Max length of line in config file.
+#define MAX_CONF_LEN	1024
+
+// Supported config value-types.
+typedef enum {
+	CF_NONE=0,
+	CF_INT,
+	CF_BOOL,
+	CF_STR,
+	CF_PATH,
+#if 0
+	CF_CVAR,
+	CF_CMD,
+#endif
+} cf_type_t;
+
+typedef mBOOL (*SETOPT_FN) (char *key, char *value);
+
+typedef struct option_s {
+	char *name;		// option name
+	cf_type_t type;	// option type
+	void *dest;		// addr of destination variable, or handler function
+	char *init;		// initial value, as a string, just as config file would
+} option_t;
+
+class MConfig {
+	private:
+		// data
+		option_t *list;
+		char *filename;
+		// functions
+		option_t *find(char *lookup);
+		mBOOL set(option_t *setp, char *value);
+		// Private; to satisfy -Weffc++ "has pointer data members but does
+		// not override" copy/assignment constructor.
+		void operator=(const MConfig &src);
+		MConfig(const MConfig &src);
+	public:
+		// contructor
+		MConfig(void);
+		// data
+		int debuglevel;		// to use for meta_debug
+		char *gamedll;		// string if specified in config.ini
+		char *plugins_file;	// ie metamod.ini, plugins.ini
+		char *exec_cfg;		// ie metaexec.cfg, exec.cfg
+		// functions
+		void init(option_t *global_options);
+		mBOOL load(char *filename);
+		mBOOL set(char *key, char *value);
+		void show(void);
+};
+
+#endif /* CONF_META_H */
diff --git a/sdk/metamod/dllapi.h b/sdk/metamod/dllapi.h
new file mode 100644
index 0000000..01e7f95
--- /dev/null
+++ b/sdk/metamod/dllapi.h
@@ -0,0 +1,192 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// dllapi.h - prototypes and typedefs for Half-Life DLL API routines
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 DLLAPI_H
+#define DLLAPI_H
+
+#include "sdk_util.h"	// BOOL
+#include "osdep.h"		// DLLEXPORT, etc
+
+// Typedefs for these are provided in SDK engine/eiface.h, but I didn't
+// like the names (APIFUNCTION, APIFUNCTION2, NEW_DLL_FUNCTIONS_FN).
+typedef int (*GETENTITYAPI_FN) (DLL_FUNCTIONS *pFunctionTable, int interfaceVersion);
+typedef int (*GETENTITYAPI2_FN) (DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion);
+typedef int (*GETNEWDLLFUNCTIONS_FN) (NEW_DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion);
+
+// From SDK dlls/cbase.h:
+C_DLLEXPORT int GetEntityAPI( DLL_FUNCTIONS *pFunctionTable, int interfaceVersion );
+C_DLLEXPORT int GetEntityAPI2( DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion );
+
+// No example in SDK..
+// From Adminmod dll.cpp:
+C_DLLEXPORT int GetNewDLLFunctions( NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion );
+
+
+// From SDK dlls/game.h:
+extern void mm_GameDLLInit( void );
+
+// From SDK dlls/cbase.h:
+extern int mm_DispatchSpawn( edict_t *pent );
+extern void mm_DispatchThink( edict_t *pent );
+extern void mm_DispatchUse( edict_t *pentUsed, edict_t *pentOther );
+extern void mm_DispatchTouch( edict_t *pentTouched, edict_t *pentOther );
+extern void mm_DispatchBlocked( edict_t *pentBlocked, edict_t *pentOther );
+extern void mm_DispatchKeyValue( edict_t *pentKeyvalue, KeyValueData *pkvd );
+extern void mm_DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData );
+extern int  mm_DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity );
+extern void mm_DispatchObjectCollisionBox( edict_t *pent );
+extern void mm_SaveWriteFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
+extern void mm_SaveReadFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
+extern void mm_SaveGlobalState( SAVERESTOREDATA *pSaveData );
+extern void mm_RestoreGlobalState( SAVERESTOREDATA *pSaveData );
+extern void mm_ResetGlobalState( void );
+
+// From SDK dlls/client.h:
+extern BOOL mm_ClientConnect( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] );
+extern void mm_ClientDisconnect( edict_t *pEntity );
+extern void mm_ClientKill( edict_t *pEntity );
+extern void mm_ClientPutInServer( edict_t *pEntity );
+extern void mm_ClientCommand( edict_t *pEntity );
+extern void mm_ClientUserInfoChanged( edict_t *pEntity, char *infobuffer );
+extern void mm_ServerActivate( edict_t *pEdictList, int edictCount, int clientMax );
+extern void mm_ServerDeactivate( void );
+extern void mm_PlayerPreThink( edict_t *pEntity );
+extern void mm_PlayerPostThink( edict_t *pEntity );
+extern void mm_StartFrame( void );
+extern void mm_ParmsNewLevel( void );
+extern void mm_ParmsChangeLevel( void );
+extern const char *mm_GetGameDescription( void );
+extern void mm_PlayerCustomization( edict_t *pEntity, customization_t *pCust );
+extern void mm_SpectatorConnect ( edict_t *pEntity );
+extern void mm_SpectatorDisconnect ( edict_t *pEntity );
+extern void mm_SpectatorThink ( edict_t *pEntity );
+extern void mm_Sys_Error( const char *error_string );
+
+// From SDK pm_shared/pm_shared.h:
+extern void mm_PM_Move ( struct playermove_s *ppmove, int server );
+extern void mm_PM_Init ( struct playermove_s *ppmove );
+extern char mm_PM_FindTextureType ( char *name );
+
+// From SDK dlls/client.h:
+extern void mm_SetupVisibility( edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas );
+extern void mm_UpdateClientData ( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd );
+extern int mm_AddToFullPack( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet );
+extern void mm_CreateBaseline( int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs );
+extern void mm_RegisterEncoders( void );
+extern int mm_GetWeaponData( struct edict_s *player, struct weapon_data_s *info );
+extern void mm_CmdStart( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed );
+extern void mm_CmdEnd ( const edict_t *player );
+extern int mm_ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
+extern int mm_GetHullBounds( int hullnumber, float *mins, float *maxs );
+extern void mm_CreateInstancedBaselines ( void );
+extern int mm_InconsistentFile( const edict_t *player, const char *filename, char *disconnect_message );
+extern int mm_AllowLagCompensation( void );
+
+// No example from SDK...
+extern void mm_OnFreeEntPrivateData(edict_t pEnt);
+extern void mm_GameShutdown(void);
+extern int mm_ShouldCollide(edict_t *pentTouched, edict_t *pentOther);
+//Added 2005-08-11 (no SDK update)
+extern void mm_CvarValue(const edict_t *pEnt, const char *value);   //! Obsolete! Use mm_CvarValue2 instead
+//Added 2005-11-22 (no SDK update)
+extern void mm_CvarValue2(const edict_t *pEnt, int requestID, const char *cvarName, const char *value);
+
+
+// Typedefs for the above functions:
+
+typedef void (*FN_GAMEINIT) ( void );
+typedef int (*FN_DISPATCHSPAWN) ( edict_t *pent );
+typedef void (*FN_DISPATCHTHINK) ( edict_t *pent );
+typedef void (*FN_DISPATCHUSE) ( edict_t *pentUsed, edict_t *pentOther );
+typedef void (*FN_DISPATCHTOUCH) ( edict_t *pentTouched, edict_t *pentOther );
+typedef void (*FN_DISPATCHBLOCKED) ( edict_t *pentBlocked, edict_t *pentOther );
+typedef void (*FN_DISPATCHKEYVALUE) ( edict_t *pentKeyvalue, KeyValueData *pkvd );
+typedef void (*FN_DISPATCHSAVE) ( edict_t *pent, SAVERESTOREDATA *pSaveData );
+typedef int (*FN_DISPATCHRESTORE) ( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity );
+typedef void (*FN_DISPATCHOBJECTCOLLISIONBOX) ( edict_t *pent );
+typedef void (*FN_SAVEWRITEFIELDS) ( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
+typedef void (*FN_SAVEREADFIELDS) ( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
+typedef void (*FN_SAVEGLOBALSTATE) ( SAVERESTOREDATA *pSaveData );
+typedef void (*FN_RESTOREGLOBALSTATE) ( SAVERESTOREDATA *pSaveData );
+typedef void (*FN_RESETGLOBALSTATE) ( void );
+
+typedef BOOL (*FN_CLIENTCONNECT) ( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] );
+typedef void (*FN_CLIENTDISCONNECT) ( edict_t *pEntity );
+typedef void (*FN_CLIENTKILL) ( edict_t *pEntity );
+typedef void (*FN_CLIENTPUTINSERVER) ( edict_t *pEntity );
+typedef void (*FN_CLIENTCOMMAND) ( edict_t *pEntity );
+typedef void (*FN_CLIENTUSERINFOCHANGED) ( edict_t *pEntity, char *infobuffer );
+typedef void (*FN_SERVERACTIVATE) ( edict_t *pEdictList, int edictCount, int clientMax );
+typedef void (*FN_SERVERDEACTIVATE) ( void );
+typedef void (*FN_PLAYERPRETHINK) ( edict_t *pEntity );
+typedef void (*FN_PLAYERPOSTTHINK) ( edict_t *pEntity );
+typedef void (*FN_STARTFRAME) ( void );
+typedef void (*FN_PARMSNEWLEVEL) ( void );
+typedef void (*FN_PARMSCHANGELEVEL) ( void );
+typedef const char *(*FN_GETGAMEDESCRIPTION) ( void );
+typedef void (*FN_PLAYERCUSTOMIZATION) ( edict_t *pEntity, customization_t *pCust );
+typedef void (*FN_SPECTATORCONNECT)  ( edict_t *pEntity );
+typedef void (*FN_SPECTATORDISCONNECT)  ( edict_t *pEntity );
+typedef void (*FN_SPECTATORTHINK)  ( edict_t *pEntity );
+typedef void (*FN_SYS_ERROR) ( const char *error_string );
+
+typedef void (*FN_PM_MOVE) ( struct playermove_s *ppmove, int server );
+typedef void (*FN_PM_INIT) ( struct playermove_s *ppmove );
+typedef char (*FN_PM_FINDTEXTURETYPE) ( char *name );
+
+typedef void (*FN_SETUPVISIBILITY) ( edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas );
+typedef void (*FN_UPDATECLIENTDATA)  ( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd );
+typedef int (*FN_ADDTOFULLPACK) ( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet );
+typedef 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 );
+typedef void (*FN_REGISTERENCODERS) ( void );
+typedef int (*FN_GETWEAPONDATA) ( struct edict_s *player, struct weapon_data_s *info );
+typedef void (*FN_CMDSTART) ( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed );
+typedef void (*FN_CMDEND)  ( const edict_t *player );
+typedef int (*FN_CONNECTIONLESSPACKET) ( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
+typedef int (*FN_GETHULLBOUNDS) ( int hullnumber, float *mins, float *maxs );
+typedef void (*FN_CREATEINSTANCEDBASELINES)  ( void );
+typedef int (*FN_INCONSISTENTFILE) ( const edict_t *player, const char *filename, char *disconnect_message );
+typedef int (*FN_ALLOWLAGCOMPENSATION) ( void );
+
+typedef void (*FN_ONFREEENTPRIVATEDATA) (edict_t *pEnt);
+typedef void (*FN_GAMESHUTDOWN) (void);
+typedef int (*FN_SHOULDCOLLIDE) (edict_t *pentTouched, edict_t *pentOther);
+//Added 2005-08-11 (no SDK update)
+typedef void (*FN_CVARVALUE)(const edict_t *pEnt, const char *value);   //! Obsolete! Use FN_CVARVALUE2 instead
+//Added 2005-11-22 (no SDK update)
+typedef void (*FN_CVARVALUE2)(const edict_t *pEnt, int requestID, const char *cvarName, const char *value);
+
+#endif /* DLLAPI_H */
diff --git a/sdk/metamod/engine_api.h b/sdk/metamod/engine_api.h
new file mode 100644
index 0000000..13f2544
--- /dev/null
+++ b/sdk/metamod/engine_api.h
@@ -0,0 +1,464 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// engine_api.h - prototypes and typedefs for Half-Life engine functions
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 ENGINE_API_H
+#define ENGINE_API_H
+
+#include <archtypes.h>
+
+// Plugin's GetEngineFunctions, called by metamod.
+typedef int (*GET_ENGINE_FUNCTIONS_FN) (enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion);
+
+// According to SDK engine/eiface.h:
+//! enginefuncs_t
+//! ONLY ADD NEW FUNCTIONS TO THE END OF THIS STRUCT.  INTERFACE VERSION IS FROZEN AT 138
+#define ENGINE_INTERFACE_VERSION 138
+
+// Protect against other projects which use this include file but use the
+// normal enginefuncs_t type for their meta_engfuncs.
+#ifdef METAMOD_CORE
+#  include "meta_eiface.h"    // meta_enginefuncs_t
+extern meta_enginefuncs_t meta_engfuncs;
+#else
+extern enginefuncs_t meta_engfuncs;
+#endif
+
+// From SDK engine/eiface.h:
+extern int mm_PrecacheModel(char *s);
+extern int mm_PrecacheSound(char *s);
+extern void mm_SetModel(edict_t *e, const char *m);
+extern int mm_ModelIndex(const char *m);
+extern int mm_ModelFrames(int modelIndex);
+
+extern void mm_SetSize(edict_t *e, const float *rgflMin, const float *rgflMax);
+extern void mm_ChangeLevel(char *s1, char *s2);
+extern void mm_GetSpawnParms(edict_t *ent);
+extern void mm_SaveSpawnParms(edict_t *ent);
+
+extern float mm_VecToYaw(const float *rgflVector);
+extern void mm_VecToAngles(const float *rgflVectorIn, float *rgflVectorOut);
+extern void mm_MoveToOrigin(edict_t *ent, const float *pflGoal, float dist, int iMoveType);
+extern void mm_ChangeYaw(edict_t *ent);
+extern void mm_ChangePitch(edict_t *ent);
+
+extern edict_t *mm_FindEntityByString(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue);
+extern int mm_GetEntityIllum(edict_t *pEnt);
+extern edict_t *mm_FindEntityInSphere(edict_t *pEdictStartSearchAfter, const float *org, float rad);
+extern edict_t *mm_FindClientInPVS(edict_t *pEdict);
+extern edict_t *mm_EntitiesInPVS(edict_t *pplayer);
+
+extern void mm_MakeVectors(const float *rgflVector);
+extern void mm_AngleVectors(const float *rgflVector, float *forward, float *right, float *up);
+
+extern edict_t *mm_CreateEntity(void);
+extern void mm_RemoveEntity(edict_t *e);
+extern edict_t *mm_CreateNamedEntity(int className);
+
+extern void mm_MakeStatic(edict_t *ent);
+extern int mm_EntIsOnFloor(edict_t *e);
+extern int mm_DropToFloor(edict_t *e);
+
+extern int mm_WalkMove(edict_t *ent, float yaw, float dist, int iMode);
+extern void mm_SetOrigin(edict_t *e, const float *rgflOrigin);
+
+extern void mm_EmitSound(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch);
+extern void mm_EmitAmbientSound(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch);
+
+extern void mm_TraceLine(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+extern void mm_TraceToss(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr);
+extern int mm_TraceMonsterHull(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+extern void mm_TraceHull(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr);
+extern void mm_TraceModel(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr);
+extern const char *mm_TraceTexture(edict_t *pTextureEntity, const float *v1, const float *v2 );
+extern void mm_TraceSphere(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr);
+extern void mm_GetAimVector(edict_t *ent, float speed, float *rgflReturn);
+
+extern void mm_ServerCommand(char *str);
+extern void mm_ServerExecute(void);
+extern void ClientCommand(edict_t *pEdict, char *szFmt, ...);
+
+extern void mm_ParticleEffect(const float *org, const float *dir, float color, float count);
+extern void mm_LightStyle(int style, char *val);
+extern int mm_DecalIndex(const char *name);
+extern int mm_PointContents(const float *rgflVector);
+
+extern void mm_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+extern void mm_MessageEnd(void);
+
+extern void mm_WriteByte(int iValue);
+extern void mm_WriteChar(int iValue);
+extern void mm_WriteShort(int iValue);
+extern void mm_WriteLong(int iValue);
+extern void mm_WriteAngle(float flValue);
+extern void mm_WriteCoord(float flValue);
+extern void mm_WriteString(const char *sz);
+extern void mm_WriteEntity(int iValue);
+
+extern void mm_CVarRegister(cvar_t *pCvar);
+extern float mm_CVarGetFloat(const char *szVarName);
+extern const char* mm_CVarGetString(const char *szVarName);
+extern void mm_CVarSetFloat(const char *szVarName, float flValue);
+extern void mm_CVarSetString(const char *szVarName, const char *szValue);
+
+extern void mm_AlertMessage(ALERT_TYPE atype, char *szFmt, ...);
+#ifdef HLSDK_3_2_OLD_EIFACE
+extern void mm_EngineFprintf(FILE *pfile, char *szFmt, ...);
+#else
+extern void mm_EngineFprintf(void *pfile, char *szFmt, ...);
+#endif
+
+#ifdef HLSDK_3_2_OLD_EIFACE
+extern void *mm_PvAllocEntPrivateData(edict_t *pEdict, long cb);
+#else
+extern void *mm_PvAllocEntPrivateData(edict_t *pEdict, int32 cb);
+#endif
+extern void *mm_PvEntPrivateData(edict_t *pEdict);
+extern void mm_FreeEntPrivateData(edict_t *pEdict);
+
+extern const char *mm_SzFromIndex(int iString);
+extern int mm_AllocString(const char *szValue);
+
+extern struct entvars_s *mm_GetVarsOfEnt(edict_t *pEdict);
+extern edict_t *mm_PEntityOfEntOffset(int iEntOffset);
+extern int mm_EntOffsetOfPEntity(const edict_t *pEdict);
+extern int mm_IndexOfEdict(const edict_t *pEdict);
+extern edict_t *mm_PEntityOfEntIndex(int iEntIndex);
+extern edict_t *mm_FindEntityByVars(struct entvars_s *pvars);
+extern void *mm_GetModelPtr(edict_t *pEdict);
+
+extern int mm_RegUserMsg(const char *pszName, int iSize);
+
+extern void mm_AnimationAutomove(const edict_t *pEdict, float flTime);
+extern void mm_GetBonePosition(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles );
+
+#ifdef HLSDK_3_2_OLD_EIFACE
+extern unsigned long mm_FunctionFromName( const char *pName );
+extern const char *mm_NameForFunction( unsigned long function );
+#else
+extern uint32 mm_FunctionFromName( const char *pName );
+extern const char *mm_NameForFunction( uint32 function );
+#endif
+
+extern void mm_ClientPrintf( edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg ); //! JOHN: engine callbacks so game DLL can print messages to individual clients
+extern void mm_ServerPrint( const char *szMsg );
+
+extern const char *mm_Cmd_Args( void ); //! these 3 added 
+extern const char *mm_Cmd_Argv( int argc ); //! so game DLL can easily 
+extern int mm_Cmd_Argc( void ); //! access client 'cmd' strings
+
+extern void mm_GetAttachment(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles );
+
+extern void mm_CRC32_Init(CRC32_t *pulCRC);
+extern void mm_CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len);
+extern void mm_CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch);
+extern CRC32_t mm_CRC32_Final(CRC32_t pulCRC);
+
+#ifdef HLSDK_3_2_OLD_EIFACE
+extern long mm_RandomLong(long lLow, long lHigh);
+#else
+extern int32 mm_RandomLong(int32 lLow, int32 lHigh);
+#endif
+extern float mm_RandomFloat(float flLow, float flHigh);
+
+extern void mm_SetView(const edict_t *pClient, const edict_t *pViewent );
+extern float mm_Time( void );
+extern void mm_CrosshairAngle(const edict_t *pClient, float pitch, float yaw);
+
+extern byte * mm_LoadFileForMe(char *filename, int *pLength);
+extern void mm_FreeFile(void *buffer);
+
+extern void mm_EndSection(const char *pszSectionName); //! trigger_endsection
+extern int mm_CompareFileTime(char *filename1, char *filename2, int *iCompare);
+extern void mm_GetGameDir(char *szGetGameDir);
+extern void mm_Cvar_RegisterVariable(cvar_t *variable);
+extern void mm_FadeClientVolume(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds);
+extern void mm_SetClientMaxspeed(const edict_t *pEdict, float fNewMaxspeed);
+extern edict_t * mm_CreateFakeClient(const char *netname); //! returns NULL if fake client can't be created
+extern void mm_RunPlayerMove(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec );
+extern int mm_NumberOfEntities(void);
+
+extern char *mm_GetInfoKeyBuffer(edict_t *e); //! passing in NULL gets the serverinfo
+extern char *mm_InfoKeyValue(char *infobuffer, char *key);
+extern void mm_SetKeyValue(char *infobuffer, char *key, char *value);
+extern void mm_SetClientKeyValue(int clientIndex, char *infobuffer, char *key, char *value);
+
+extern int mm_IsMapValid(char *filename);
+extern void mm_StaticDecal( const float *origin, int decalIndex, int entityIndex, int modelIndex );
+extern int mm_PrecacheGeneric(char *s);
+extern int mm_GetPlayerUserId(edict_t *e ); //! returns the server assigned userid for this player. useful for logging frags, etc. returns -1 if the edict couldn't be found in the list of clients
+extern void mm_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);
+extern int mm_IsDedicatedServer(void);//! is this a dedicated server?
+extern cvar_t *mm_CVarGetPointer(const char *szVarName);
+extern unsigned int mm_GetPlayerWONId(edict_t *e); //! returns the server assigned WONid for this player. useful for logging frags, etc. returns -1 if the edict couldn't be found in the list of clients
+
+//! YWB 8/1/99 TFF Physics additions
+extern void mm_Info_RemoveKey( char *s, const char *key );
+extern const char *mm_GetPhysicsKeyValue( const edict_t *pClient, const char *key );
+extern void mm_SetPhysicsKeyValue( const edict_t *pClient, const char *key, const char *value );
+extern const char *mm_GetPhysicsInfoString( const edict_t *pClient );
+extern unsigned short mm_PrecacheEvent( int type, const char *psz );
+extern void mm_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 );
+
+extern unsigned char *mm_SetFatPVS( float *org );
+extern unsigned char *mm_SetFatPAS( float *org );
+
+extern int mm_CheckVisibility( const edict_t *entity, unsigned char *pset );
+
+extern void mm_DeltaSetField( struct delta_s *pFields, const char *fieldname );
+extern void mm_DeltaUnsetField( struct delta_s *pFields, const char *fieldname );
+extern void mm_DeltaAddEncoder( char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) );
+extern int mm_GetCurrentPlayer( void );
+extern int mm_CanSkipPlayer( const edict_t *player );
+extern int mm_DeltaFindField( struct delta_s *pFields, const char *fieldname );
+extern void mm_DeltaSetFieldByIndex( struct delta_s *pFields, int fieldNumber );
+extern void mm_DeltaUnsetFieldByIndex( struct delta_s *pFields, int fieldNumber );
+
+extern void mm_SetGroupMask( int mask, int op );
+
+extern int CreateInstancedBaseline( int classname, struct entity_state_s *baseline );
+extern void mm_Cvar_DirectSet( struct cvar_s *var, char *value );
+
+//! Forces the client and server to be running with the same version of the specified file
+//!( e.g., a player model ).
+//! Calling this has no effect in single player
+extern void mm_ForceUnmodified( FORCE_TYPE type, float *mins, float *maxs, const char *filename );
+
+extern void mm_GetPlayerStats( const edict_t *pClient, int *ping, int *packet_loss );
+
+extern void mm_AddServerCommand( char *cmd_name, void (*function) (void) );
+// Added in SDK 2.2:
+extern qboolean mm_Voice_GetClientListening(int iReceiver, int iSender);
+extern qboolean mm_Voice_SetClientListening(int iReceiver, int iSender, qboolean bListen);
+// Added for HL 1109 (no SDK update):
+extern const char *mm_pfnGetPlayerAuthId(edict_t *e);
+// Added 2003-11-10 (no SDK update):
+extern sequenceEntry_s * mm_SequenceGet(const char* fileName, const char* entryName);
+extern sentenceEntry_s * mm_SequencePickSentence(const char* groupName, int pickMethod, int *picked);
+extern int mm_GetFileSize(char *filename);
+extern unsigned int mm_GetApproxWavePlayLen(const char *filepath);
+extern int mm_IsCareerMatch(void);
+extern int mm_GetLocalizedStringLength(const char *label);
+extern void mm_RegisterTutorMessageShown(int mid);
+extern int mm_GetTimesTutorMessageShown(int mid);
+extern void mm_ProcessTutorMessageDecayBuffer(int *buffer, int bufferLength);
+extern void mm_ConstructTutorMessageDecayBuffer(int *buffer, int bufferLength);
+extern void mm_ResetTutorMessageDecayData(void);
+//Added 2005-08-11 (no SDK update)
+extern void mm_QueryClientCvarValue(const edict_t *pEdict, const char *cvarName);    //! Obsolete! Use mm_QueryClientCvarValue2 instead
+//Added 2005-11-22 (no SDK update)
+extern void mm_QueryClientCvarValue2(const edict_t *pEdict, const char *cvarName, int requestID);
+
+
+// Typedefs for the above functions:
+
+typedef int (*FN_PRECACHEMODEL) (char* s);
+typedef int (*FN_PRECACHESOUND) (char* s);
+typedef void (*FN_SETMODEL) (edict_t *e, const char *m);
+typedef int (*FN_MODELINDEX) (const char *m);
+typedef int (*FN_MODELFRAMES) (int modelIndex);
+typedef void (*FN_SETSIZE) (edict_t *e, const float *rgflMin, const float *rgflMax);
+typedef void (*FN_CHANGELEVEL) (char *s1, char *s2);
+typedef void (*FN_GETSPAWNPARMS) (edict_t *ent);
+typedef void (*FN_SAVESPAWNPARMS) (edict_t *ent);
+typedef float (*FN_VECTOYAW) (const float *rgflVector);
+typedef void (*FN_VECTOANGLES) (const float *rgflVectorIn, float *rgflVectorOut);
+typedef void (*FN_MOVETOORIGIN) (edict_t *ent, const float *pflGoal, float dist, int iMoveType);
+typedef void (*FN_CHANGEYAW) (edict_t *ent);
+typedef void (*FN_CHANGEPITCH) (edict_t *ent);
+typedef edict_t * (*FN_FINDENTITYBYSTRING) (edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue);
+typedef int (*FN_GETENTITYILLUM) (edict_t *pEnt);
+typedef edict_t * (*FN_FINDENTITYINSPHERE) (edict_t *pEdictStartSearchAfter, const float *org, float rad);
+typedef edict_t * (*FN_FINDCLIENTINPVS) (edict_t *pEdict);
+typedef edict_t * (*FN_ENTITIESINPVS) (edict_t *pplayer);
+typedef void (*FN_MAKEVECTORS) (const float *rgflVector);
+typedef void (*FN_ANGLEVECTORS) (const float *rgflVector, float *forward, float *right, float *up);
+typedef edict_t * (*FN_CREATEENTITY) (void);
+typedef void (*FN_REMOVEENTITY) (edict_t *e);
+typedef edict_t * (*FN_CREATENAMEDENTITY) (int className);
+typedef void (*FN_MAKESTATIC) (edict_t *ent);
+typedef int (*FN_ENTISONFLOOR) (edict_t *e);
+typedef int (*FN_DROPTOFLOOR) (edict_t *e);
+typedef int (*FN_WALKMOVE) (edict_t *ent, float yaw, float dist, int iMode);
+typedef void (*FN_SETORIGIN) (edict_t *e, const float *rgflOrigin);
+typedef void (*FN_EMITSOUND) (edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch);
+typedef void (*FN_EMITAMBIENTSOUND) (edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch);
+typedef void (*FN_TRACELINE) (const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+typedef void (*FN_TRACETOSS) (edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr);
+typedef int (*FN_TRACEMONSTERHULL) (edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+typedef void (*FN_TRACEHULL) (const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr);
+typedef void (*FN_TRACEMODEL) (const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr);
+typedef const char * (*FN_TRACETEXTURE) (edict_t *pTextureEntity, const float *v1, const float *v2 );
+typedef void (*FN_TRACESPHERE) (const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr);
+typedef void (*FN_GETAIMVECTOR) (edict_t *ent, float speed, float *rgflReturn);
+typedef void (*FN_SERVERCOMMAND) (char *str);
+typedef void (*FN_SERVEREXECUTE) (void);
+typedef void (*FN_CLIENTCOMMAND_ENG) (edict_t *pEdict, char *szFmt, ...);
+typedef void (*FN_PARTICLEEFFECT) (const float *org, const float *dir, float color, float count);
+typedef void (*FN_LIGHTSTYLE) (int style, char *val);
+typedef int (*FN_DECALINDEX) (const char *name);
+typedef int (*FN_POINTCONTENTS) (const float *rgflVector);
+typedef void (*FN_MESSAGEBEGIN) (int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+typedef void (*FN_MESSAGEEND) (void);
+typedef void (*FN_WRITEBYTE) (int iValue);
+typedef void (*FN_WRITECHAR) (int iValue);
+typedef void (*FN_WRITESHORT) (int iValue);
+typedef void (*FN_WRITELONG) (int iValue);
+typedef void (*FN_WRITEANGLE) (float flValue);
+typedef void (*FN_WRITECOORD) (float flValue);
+typedef void (*FN_WRITESTRING) (const char *sz);
+typedef void (*FN_WRITEENTITY) (int iValue);
+typedef void (*FN_CVARREGISTER) (cvar_t *pCvar);
+typedef float (*FN_CVARGETFLOAT) (const char *szVarName);
+typedef const char * (*FN_CVARGETSTRING) (const char *szVarName);
+typedef void (*FN_CVARSETFLOAT) (const char *szVarName, float flValue);
+typedef void (*FN_CVARSETSTRING) (const char *szVarName, const char *szValue);
+typedef void (*FN_ALERTMESSAGE) (ALERT_TYPE atype, char *szFmt, ...);
+#ifdef HLSDK_3_2_OLD_EIFACE
+typedef void (*FN_ENGINEFPRINTF) (FILE *pfile, char *szFmt, ...);
+typedef void * (*FN_PVALLOCENTPRIVATEDATA) (edict_t *pEdict, long cb);
+#else
+typedef void (*FN_ENGINEFPRINTF) (void *pfile, char *szFmt, ...);
+typedef void * (*FN_PVALLOCENTPRIVATEDATA) (edict_t *pEdict, int32 cb);
+#endif
+typedef void * (*FN_PVENTPRIVATEDATA) (edict_t *pEdict);
+typedef void (*FN_FREEENTPRIVATEDATA) (edict_t *pEdict);
+typedef const char * (*FN_SZFROMINDEX) (int iString);
+typedef int (*FN_ALLOCSTRING) (const char *szValue);
+typedef struct entvars_s * (*FN_GETVARSOFENT) (edict_t *pEdict);
+typedef edict_t * (*FN_PENTITYOFENTOFFSET) (int iEntOffset);
+typedef int (*FN_ENTOFFSETOFPENTITY) (const edict_t *pEdict);
+typedef int (*FN_INDEXOFEDICT) (const edict_t *pEdict);
+typedef edict_t * (*FN_PENTITYOFENTINDEX) (int iEntIndex);
+typedef edict_t * (*FN_FINDENTITYBYVARS) (struct entvars_s *pvars);
+typedef void * (*FN_GETMODELPTR) (edict_t *pEdict);
+typedef int (*FN_REGUSERMSG) (const char *pszName, int iSize);
+typedef void (*FN_ANIMATIONAUTOMOVE) (const edict_t *pEdict, float flTime);
+typedef void (*FN_GETBONEPOSITION) (const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles );
+#ifdef HLSDK_3_2_OLD_EIFACE
+typedef unsigned long (*FN_FUNCTIONFROMNAME) ( const char *pName );
+typedef const char * (*FN_NAMEFORFUNCTION) ( unsigned long function );
+#else
+typedef uint32 (*FN_FUNCTIONFROMNAME) ( const char *pName );
+typedef const char * (*FN_NAMEFORFUNCTION) ( uint32 function );
+#endif
+typedef void (*FN_CLIENTPRINTF) ( edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg );
+typedef void (*FN_SERVERPRINT) ( const char *szMsg );
+typedef const char * (*FN_CMD_ARGS) ( void );
+typedef const char * (*FN_CMD_ARGV) ( int argc );
+typedef int (*FN_CMD_ARGC) ( void );
+typedef void (*FN_GETATTACHMENT) (const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles );
+typedef void (*FN_CRC32_INIT) (CRC32_t *pulCRC);
+typedef void (*FN_CRC32_PROCESSBUFFER) (CRC32_t *pulCRC, void *p, int len);
+typedef void (*FN_CRC32_PROCESSBYTE) (CRC32_t *pulCRC, unsigned char ch);
+typedef CRC32_t (*FN_CRC32_FINAL) (CRC32_t pulCRC);
+#ifdef HLSDK_3_2_OLD_EIFACE
+typedef long (*FN_RANDOMLONG) (long lLow, long lHigh);
+#else
+typedef int32 (*FN_RANDOMLONG) (int32 lLow, int32 lHigh);
+#endif
+typedef float (*FN_RANDOMFLOAT) (float flLow, float flHigh);
+typedef void (*FN_SETVIEW) (const edict_t *pClient, const edict_t *pViewent );
+typedef float (*FN_TIME) ( void );
+typedef void (*FN_CROSSHAIRANGLE) (const edict_t *pClient, float pitch, float yaw);
+typedef byte * (*FN_LOADFILEFORME) (char *filename, int *pLength);
+typedef void (*FN_FREEFILE) (void *buffer);
+typedef void (*FN_ENDSECTION) (const char *pszSectionName);
+typedef int (*FN_COMPAREFILETIME) (char *filename1, char *filename2, int *iCompare);
+typedef void (*FN_GETGAMEDIR) (char *szGetGameDir);
+typedef void (*FN_CVAR_REGISTERVARIABLE) (cvar_t *variable);
+typedef void (*FN_FADECLIENTVOLUME) (const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds);
+typedef void (*FN_SETCLIENTMAXSPEED) (const edict_t *pEdict, float fNewMaxspeed);
+typedef edict_t * (*FN_CREATEFAKECLIENT) (const char *netname);
+typedef void (*FN_RUNPLAYERMOVE) (edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec );
+typedef int (*FN_NUMBEROFENTITIES) (void);
+typedef char * (*FN_GETINFOKEYBUFFER) (edict_t *e);
+typedef char * (*FN_INFOKEYVALUE) (char *infobuffer, char *key);
+typedef void (*FN_SETKEYVALUE) (char *infobuffer, char *key, char *value);
+typedef void (*FN_SETCLIENTKEYVALUE) (int clientIndex, char *infobuffer, char *key, char *value);
+typedef int (*FN_ISMAPVALID) (char *filename);
+typedef void (*FN_STATICDECAL) ( const float *origin, int decalIndex, int entityIndex, int modelIndex );
+typedef int (*FN_PRECACHEGENERIC) (char *s);
+typedef int (*FN_GETPLAYERUSERID) (edict_t *e );
+typedef 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);
+typedef int (*FN_ISDEDICATEDSERVER) (void);
+typedef cvar_t * (*FN_CVARGETPOINTER) (const char *szVarName);
+typedef unsigned int (*FN_GETPLAYERWONID) (edict_t *e);
+typedef void (*FN_INFO_REMOVEKEY) ( char *s, const char *key );
+typedef const char * (*FN_GETPHYSICSKEYVALUE) ( const edict_t *pClient, const char *key );
+typedef void (*FN_SETPHYSICSKEYVALUE) ( const edict_t *pClient, const char *key, const char *value );
+typedef const char * (*FN_GETPHYSICSINFOSTRING) ( const edict_t *pClient );
+typedef unsigned short (*FN_PRECACHEEVENT) ( int type, const char *psz );
+typedef 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 );
+typedef unsigned char * (*FN_SETFATPVS) ( float *org );
+typedef unsigned char * (*FN_SETFATPAS) ( float *org );
+typedef int (*FN_CHECKVISIBILITY) ( const edict_t *entity, unsigned char *pset );
+typedef void (*FN_DELTASETFIELD) ( struct delta_s *pFields, const char *fieldname );
+typedef void (*FN_DELTAUNSETFIELD) ( struct delta_s *pFields, const char *fieldname );
+typedef void (*FN_DELTAADDENCODER) ( char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) );
+typedef int (*FN_GETCURRENTPLAYER) ( void );
+typedef int (*FN_CANSKIPPLAYER) ( const edict_t *player );
+typedef int (*FN_DELTAFINDFIELD) ( struct delta_s *pFields, const char *fieldname );
+typedef void (*FN_DELTASETFIELDBYINDEX) ( struct delta_s *pFields, int fieldNumber );
+typedef void (*FN_DELTAUNSETFIELDBYINDEX) ( struct delta_s *pFields, int fieldNumber );
+typedef void (*FN_SETGROUPMASK) ( int mask, int op );
+typedef int (*FN_CREATEINSTANCEDBASELINE) ( int classname, struct entity_state_s *baseline );
+typedef void (*FN_CVAR_DIRECTSET) ( struct cvar_s *var, char *value );
+typedef void (*FN_FORCEUNMODIFIED) ( FORCE_TYPE type, float *mins, float *maxs, const char *filename );
+typedef void (*FN_GETPLAYERSTATS) ( const edict_t *pClient, int *ping, int *packet_loss );
+typedef void (*FN_ADDSERVERCOMMAND) ( char *cmd_name, void (*function) (void) );
+// Added in SDK 2.2:
+typedef qboolean (*FN_VOICE_GETCLIENTLISTENING) (int iReceiver, int iSender);
+typedef qboolean (*FN_VOICE_SETCLIENTLISTENING) (int iReceiver, int iSender, qboolean bListen);
+// Added for HL 1109 (no SDK update):
+typedef const char * (*FN_GETPLAYERAUTHID) (edict_t *e);
+// Added 2003-11-10 (no SDK update):
+typedef sequenceEntry_s * (*FN_SEQUENCEGET) (const char* fileName, const char* entryName);
+typedef sentenceEntry_s * (*FN_SEQUENCEPICKSENTENCE) (const char* groupName, int pickMethod, int *picked);
+typedef int (*FN_GETFILESIZE) (char *filename);
+typedef unsigned int (*FN_GETAPPROXWAVEPLAYLEN) (const char *filepath);
+typedef int (*FN_ISCAREERMATCH) (void);
+typedef int (*FN_GETLOCALIZEDSTRINGLENGTH) (const char *label);
+typedef void (*FN_REGISTERTUTORMESSAGESHOWN) (int mid);
+typedef int (*FN_GETTIMESTUTORMESSAGESHOWN) (int mid);
+typedef void (*FN_PROCESSTUTORMESSAGEDECAYBUFFER) (int *buffer, int bufferLength);
+typedef void (*FN_CONSTRUCTTUTORMESSAGEDECAYBUFFER) (int *buffer, int bufferLength);
+typedef void (*FN_RESETTUTORMESSAGEDECAYDATA) (void);
+//Added 2005-08-11 (no SDK update)
+typedef void (*FN_QUERYCLIENTCVARVALUE)(const edict_t *pEdict, const char *cvarName);  //! Obsolete! Use FN_QUERYCLIENTCVARVALUE2 instead
+//Added 2005-11-22 (no SDK update)
+typedef void (*FN_QUERYCLIENTCVARVALUE2)(const edict_t *pEdict, const char *cvarName, int requestID);
+
+#endif /* ENGINE_API_H */
diff --git a/sdk/metamod/engine_t.h b/sdk/metamod/engine_t.h
new file mode 100644
index 0000000..04149b1
--- /dev/null
+++ b/sdk/metamod/engine_t.h
@@ -0,0 +1,81 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// engine_t.h - The engine_t type
+
+/*
+ * Copyright (c) 2001-2006 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 MM_ENGINE_T_H
+#define MM_ENGINE_T_H
+
+#include "eiface.h"             // engfuncs_t, globalvars_t
+#include "engineinfo.h"         // EngineInfo
+
+
+// Our structure for storing engine references.
+struct engine_t {
+    engine_t();
+    engine_t(const engine_t&);
+    engine_t& operator=(const engine_t&);
+
+	enginefuncs_t	*funcs;			// engine funcs
+	globalvars_t	*globals;		// engine globals
+	enginefuncs_t	*pl_funcs;		// "modified" eng funcs we give to plugins
+    EngineInfo       info;          // some special info elements
+};
+
+inline engine_t::engine_t() 
+    : funcs(NULL), globals(NULL), pl_funcs(NULL), info() 
+{
+}
+
+
+inline engine_t::engine_t(const engine_t& _rhs) 
+    : funcs(_rhs.funcs), globals(_rhs.globals), pl_funcs(_rhs.pl_funcs), info(_rhs.info) 
+{
+}
+
+
+inline engine_t& engine_t::operator=(const engine_t& _rhs) 
+{
+    funcs = _rhs.funcs;
+    globals = _rhs.globals;
+    pl_funcs = _rhs.pl_funcs;
+    info = _rhs.info;
+    return *this;
+}
+
+
+extern engine_t Engine;
+
+#endif /* MM_ENGINE_T_H */
+
diff --git a/sdk/metamod/enginecallbacks.h b/sdk/metamod/enginecallbacks.h
new file mode 100644
index 0000000..59a1f0b
--- /dev/null
+++ b/sdk/metamod/enginecallbacks.h
@@ -0,0 +1,78 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// enginecallbacks.h - wrapper for <enginecallback.h>
+
+/*
+ * Copyright (c) 2001-2006 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 MM_ENGINECALLBACKS_H
+#define MM_ENGINECALLBACKS_H
+
+// This file is a wrapper around the SDK's enginecallback.h file. We need
+// this because we use a different type for the global object g_engfuncs,
+// which is still compatible with the enginefuncs_t that the SDK
+// uses.
+// This is only done for files that belong to Metamod, not other projects
+// like plugins that use this file, or others that include it, too.
+// Since we don't have a clean seperation of include files right now we
+// "hack" our way around that by using a flag METAMOD_CORE which is set 
+// when compiling Metamod proper.
+
+#ifdef METAMOD_CORE
+#  include "meta_eiface.h"        // HL_enginefuncs_t
+
+// Use a #define to bend the enginefuncs_t type to our HL_enginefuncs_t
+// type instead as we now use that for the global object g_engfuncs.
+#  define enginefuncs_t HL_enginefuncs_t
+#endif /* METAMOD_CORE */
+
+#include <enginecallback.h>		// ALERT, etc
+
+#ifdef METAMOD_CORE
+#  undef enginefuncs_t
+#endif /* METAMOD_CORE */
+
+// Also, create some additional macros for engine callback functions, which
+// weren't in SDK dlls/enginecallbacks.h but probably should have been.
+
+#define GET_INFOKEYBUFFER	    	(*g_engfuncs.pfnGetInfoKeyBuffer)
+#define INFOKEY_VALUE			    (*g_engfuncs.pfnInfoKeyValue)
+#define SET_CLIENT_KEYVALUE	    	(*g_engfuncs.pfnSetClientKeyValue)
+#define REG_SVR_COMMAND	    		(*g_engfuncs.pfnAddServerCommand)
+#define SERVER_PRINT			    (*g_engfuncs.pfnServerPrint)
+#define SET_SERVER_KEYVALUE	    	(*g_engfuncs.pfnSetKeyValue)
+#define QUERY_CLIENT_CVAR_VALUE	    (*g_engfuncs.pfnQueryClientCvarValue)
+#define QUERY_CLIENT_CVAR_VALUE2	(*g_engfuncs.pfnQueryClientCvarValue2)
+
+
+#endif /* MM_ENGINECALLBACKS_H */
+
diff --git a/sdk/metamod/engineinfo.h b/sdk/metamod/engineinfo.h
new file mode 100644
index 0000000..2937ff3
--- /dev/null
+++ b/sdk/metamod/engineinfo.h
@@ -0,0 +1,255 @@
+
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// engineinfo.h - info about HL engine, like file used and 
+//                text segment range
+//
+
+#ifndef MM_ENGINEINFO_H
+#define MM_ENGINEINFO_H
+
+
+
+#ifdef _WIN32
+typedef void* MemAddr;
+#else
+#  include <link.h>           // ElfW(Addr/Phdr) macros
+typedef void* MemAddr;
+#endif /* _WIN32 */ 
+
+#include "extdll.h"           // eiface.h: enginefuncs_t
+
+
+// What we return in is_valid_code_pointer() when the EngineInfo object is
+// in an INVALID state, i.e. no code address range could be determined.
+static const bool c_DefaultReturnOnInvalidState = true;
+
+static const int  c_EngineInfo__typeLen = 10;
+
+
+class EngineInfo
+{
+	private:
+	// data :
+
+		MemAddr m_codeStart;
+		MemAddr m_codeEnd;
+        
+        // State is either NULL  when not yet initialised,
+        //                 VALID if a code range could be determined
+        //              or INVALID when no valid range for code addresses
+        //                 could be determined.
+        char m_state;
+
+        // Type of engine dso/dll used.
+        // For Linux this specifies the architecture, i.e. 'i486', 'i686', 
+        // 'amd', 'amd64' etc.
+        // For Windows this is either 'sw' or 'hw' or 'swds' depending on
+        // the server type.
+		char    m_type[c_EngineInfo__typeLen]; 
+
+	// functions :
+
+
+        // Check if string is valid name of engine dso/dll.
+		bool check_for_engine_module( const char* pName );
+        
+#ifdef _WIN32
+
+        // Set info using the PE header found by module name.
+        // Returns 0 on success, error code on failure.
+        int  nthdr_module_name( void );
+
+		int vac_pe_approx( enginefuncs_t* pFuncs );
+
+        // Set code segment start and end from PEheader. The base
+        // address, that relative addresses are based on, is passed in
+        // pBase.
+        void set_code_range( unsigned char* pBase, PIMAGE_NT_HEADERS pNThdr );
+
+#else
+        
+        // Set info using the Programheader found via r_debug struct.
+        // Returns 0 on success, error code on failure.
+		int  phdr_r_debug( void );
+        // Set info using the Programheader found with reference address
+        // via dladdr(). Returns 0 on success, error code on failure.
+		int  phdr_dladdr( void* pMem );
+        // Set info using the Programheader found via ELF header passed as
+        // pElfHdr. Return 0 on success, error code on failure.
+		int  phdr_elfhdr( void* pElfHdr );
+        // Set code segment start and end from Programheader. The base
+        // address, that relative addresses are based on, is passed in
+        // pBase.
+        void set_code_range( void* pBase, ElfW(Phdr)* pPhdr );
+        
+#endif /* _WIN32 */ 
+
+	public:
+    // codes :
+
+    enum {
+        STATE_NULL = 0,
+        STATE_VALID,
+        STATE_INVALID,
+        
+        MODULE_NAME_NOTFOUND = 5,
+        INVALID_DOS_SIGN,
+        INVALID_NT_SIGN,
+        INVALID_ARG,
+        HEADER_NOTFOUND,
+        NOTFOUND
+    };
+
+        
+    // functions :
+
+		EngineInfo();
+        EngineInfo& operator=( const EngineInfo& );
+        EngineInfo( const EngineInfo& );
+
+        const char* type( void );
+        
+        // Initilaise object, determining the bounds of the code segment of
+        // the HL engine shared object.
+		int initialise( enginefuncs_t* pFuncs  = NULL );
+        
+        // Test if pMem is within bounds of the code segment.
+		bool is_valid_code_pointer( void* pMem );
+
+        // Overloaded versions of above test to keep the ugly pointer
+        // conversion stuff in here.
+        bool is_valid_code_pointer(      const char* (*fp) (edict_t*) );
+        bool is_valid_code_pointer( sequenceEntry_s* (*fp) (const char*, const char*) );
+        bool is_valid_code_pointer( sentenceEntry_s* (*fp) (const char*, int, int*) );
+        bool is_valid_code_pointer(              int (*fp) (char*) );
+        bool is_valid_code_pointer(     unsigned int (*fp) (const char*) );
+        bool is_valid_code_pointer(              int (*fp) (void) );
+        bool is_valid_code_pointer(              int (*fp) (const char*) );
+        bool is_valid_code_pointer(             void (*fp) (int) );
+        bool is_valid_code_pointer(              int (*fp) (int) );
+        bool is_valid_code_pointer(             void (*fp) (int*, int) );
+        bool is_valid_code_pointer(             void (*fp) (void) );
+        bool is_valid_code_pointer(             void (*fp) (const edict_t*, const char*) );
+        bool is_valid_code_pointer(             void (*fp) (const edict_t*, const char*, int) );
+
+ 
+};
+
+
+
+// We probably should run an initialisation here without a reference
+// pointer so that the object has valid info in any case. 
+inline EngineInfo::EngineInfo() :
+	m_codeStart(NULL),
+	m_codeEnd(NULL),
+    m_state(STATE_NULL)
+{
+	m_type[0] = '\0';	
+}
+
+
+inline EngineInfo::EngineInfo( const EngineInfo& _rhs) :
+	m_codeStart(_rhs.m_codeStart),
+	m_codeEnd(_rhs.m_codeEnd),
+    m_state(STATE_NULL)
+{
+	memcpy( m_type, _rhs.m_type, c_EngineInfo__typeLen );
+}
+
+
+inline EngineInfo& EngineInfo::operator=( const EngineInfo& _rhs)
+{
+    m_state = _rhs.m_state;
+	m_codeStart = _rhs.m_codeStart;
+	m_codeEnd = _rhs.m_codeEnd;
+	memcpy( m_type, _rhs.m_type, c_EngineInfo__typeLen );
+    return *this;
+}
+
+
+inline const char* EngineInfo::type( void )
+{
+    return m_type;
+}
+
+inline bool EngineInfo::is_valid_code_pointer( void* _pMem )
+{
+    if ( STATE_INVALID == m_state ) {
+        return c_DefaultReturnOnInvalidState;
+    }
+	if ( NULL != _pMem && m_codeStart <= _pMem && _pMem <= m_codeEnd ) {
+        return true;
+    }
+
+	return false;
+}
+
+inline bool EngineInfo::is_valid_code_pointer( const char* (*_fp) (edict_t*) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( sequenceEntry_s* (*_fp) (const char*, const char*) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( sentenceEntry_s* (*_fp) (const char*, int, int*) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( int (*_fp) (char*) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( unsigned int (*_fp) (const char*) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( int (*_fp) (void) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( int (*_fp) (const char*) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( void (*_fp) (int) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( int (*_fp) (int) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( void (*_fp) (int*, int) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( void (*_fp) (void) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( void (*_fp) (const edict_t*, const char*) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+inline bool EngineInfo::is_valid_code_pointer( void (*_fp) (const edict_t*, const char*, int) )
+{
+    return is_valid_code_pointer( (void*)_fp );
+}
+
+#endif /* MM_ENGINEINFO_H */
+
diff --git a/sdk/metamod/game_support.h b/sdk/metamod/game_support.h
new file mode 100644
index 0000000..134fda0
--- /dev/null
+++ b/sdk/metamod/game_support.h
@@ -0,0 +1,55 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// game_support.h - structures for supporting different HL mod "games"
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 GAME_SUPPORT_H
+#define GAME_SUPPORT_H
+
+#include "types_meta.h"		// mBOOL
+#include "metamod.h"		// gamedll_t
+
+// Information we have about each game/mod DLL.
+typedef struct game_modinfo_s {
+	char *name;			// name (the game dir)
+	char *linux_so;		// filename of linux shared lib
+	char *win_dll;		// filename of win32 dll
+	char *desc;			// our long-name description
+} game_modinfo_t;
+
+typedef game_modinfo_t game_modlist_t[];
+game_modinfo_t *lookup_game(const char *name);
+mBOOL setup_gamedll(gamedll_t *gamedll);
+
+#endif /* GAME_SUPPORT_H */
diff --git a/sdk/metamod/games.h b/sdk/metamod/games.h
new file mode 100644
index 0000000..59cf7c4
--- /dev/null
+++ b/sdk/metamod/games.h
@@ -0,0 +1,130 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+ 
+// games.h - list of supported game mods and their data
+ 
+/*
+ * Copyright (c) 2001-2006 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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.
+ *
+ */
+ 
+// This list is now kept in a separate file to facilitate generating the
+// list from game data stored in a convenient db.
+
+#ifdef __amd64__
+#  define MODARCH "_amd64"
+#else
+#  define MODARCH "_i386"
+#endif
+
+	{"action",            "ahl"MODARCH".so",          "ahl.dll",           "Action Half-Life"},
+	{"ag",                "ag"MODARCH".so",           "ag.dll",            "Adrenaline Gamer Steam"},
+	{"ag3",               "hl"MODARCH".so",           "hl.dll",            "Adrenalinegamer 3.x"},
+	{"aghl",              "ag"MODARCH".so",           "ag.dll",            "Adrenalinegamer 4.x"},
+	{"arg",               "arg"MODARCH".so",          "hl.dll",            "Arg!"},
+	{"asheep",            "hl"MODARCH".so",           "hl.dll",            "Azure Sheep"},
+	{"bg",                "bg"MODARCH".so",           "bg.dll",            "The Battle Grounds"},
+	{"bot",               "bot"MODARCH".so",          "bot.dll",           "Bot"},
+	{"brainbread",        "bb"MODARCH".so",           "bb.dll",            "Brain Bread"},
+	{"bumpercars",        "hl"MODARCH".so",           "hl.dll",            "Bumper Cars"},
+	{"buzzybots",         "bb"MODARCH".so",           "bb.dll",            "BuzzyBots"},
+	{"cs13",              "cs"MODARCH".so",           "mp.dll",            "Counter-Strike 1.3"},
+	{"cstrike",           "cs"MODARCH".so",           "mp.dll",            "Counter-Strike"},
+	{"csv15",             "cs"MODARCH".so",           "mp.dll",            "CS 1.5 for Steam"},
+	{"czero",             "cs"MODARCH".so",           "mp.dll",            "Counter-Strike:Condition Zero"},
+	{"dcrisis",           "dc"MODARCH".so",           "dc.dll",            "Desert Crisis"},
+	{"dmc",               "dmc"MODARCH".so",          "dmc.dll",           "Deathmatch Classic"},
+	{"dod",               "dod"MODARCH".so",          "dod.dll",           "Day of Defeat"},
+	{"dpb",               "pb.i386.so",               "pb.dll",            "Digital Paintball"},
+	{"dragonmodz",        "hl"MODARCH".so",           "mp.dll",            "Dragon Mod Z"},
+	{"esf",               "hl"MODARCH".so",           "hl.dll",            "Earth's Special Forces"},
+	{"existence",         "ex"MODARCH".so",           "existence.dll",     "Existence"},
+	{"firearms",          "fa"MODARCH".so",           "firearms.dll",      "Firearms"},
+	{"firearms25",        "fa"MODARCH".so",           "firearms.dll",      "Retro Firearms"},
+	{"freeze",            "mp"MODARCH".so",           "mp.dll",            "Freeze"},
+	{"frontline",         "front"MODARCH".so",        "frontline.dll",     "Frontline Force"},
+	{"gangstawars",       "gangsta"MODARCH".so",      "gwars27.dll",       "Gangsta Wars"},
+	{"gangwars",          "mp"MODARCH".so",           "mp.dll",            "Gangwars"},
+	{"gearbox",           "opfor"MODARCH".so",        "opfor.dll",         "Opposing Force"},
+	{"globalwarfare",     "gw"MODARCH".so",           "mp.dll",            "Global Warfare"},
+	{"goldeneye",         "golden"MODARCH".so",       "mp.dll",            "Goldeneye"},
+	{"hlrally",           "hlr"MODARCH".so",          "hlrally.dll",       "HL-Rally"},
+	{"holywars",          "hl"MODARCH".so",           "holywars.dll",      "Holy Wars"},
+	{"hostileintent",     "hl"MODARCH".so",           "hl.dll",            "Hostile Intent"},
+	{"ios",               "ios"MODARCH".so",          "ios.dll",           "International Online Soccer"},
+	{"judgedm",           "judge"MODARCH".so",        "mp.dll",            "Judgement"},
+	{"kanonball",         "hl"MODARCH".so",           "kanonball.dll",     "Kanonball"},
+	{"monkeystrike",      "ms"MODARCH".so",           "monkey.dll",        "Monkeystrike"},
+	{"MorbidPR",          "morbid"MODARCH".so",       "morbid.dll",        "Morbid Inclination"},
+	{"movein",            "hl"MODARCH".so",           "hl.dll",            "Move In!"},
+	{"ns",                "ns"MODARCH".so",           "ns.dll",            "Natural Selection"},
+	{"nsp",               "ns"MODARCH".so",           "ns.dll",            "Natural Selection Beta"},
+	{"oel",               "hl"MODARCH".so",           "hl.dll",            "OeL Half-Life"},
+	{"og",                "og"MODARCH".so",           "og.dll",            "Over Ground"},
+	{"ol",                "ol"MODARCH".so",           "hl.dll",            "Outlawsmod"},
+	{"ops1942",           "spirit"MODARCH".so",       "spirit.dll",        "Operations 1942"},
+	{"osjb",              "osjb"MODARCH".so",         "jail.dll",          "Open-Source Jailbreak"},
+	{"outbreak",          "none",                     "hl.dll",            "Out Break"},
+	{"oz",                "mp"MODARCH".so",           "mp.dll",            "Oz Deathmatch"},
+	{"paintball",         "pb"MODARCH".so",           "mp.dll",            "Paintball"},
+	{"penemy",            "pe"MODARCH".so",           "pe.dll",            "Public Enemy"},
+	{"phineas",           "phineas"MODARCH".so",      "phineas.dll",       "Phineas Bot"},
+	{"ponreturn",         "ponr"MODARCH".so",         "mp.dll",            "Point of No Return"},
+	{"pvk",               "hl"MODARCH".so",           "hl.dll",            "Pirates, Vikings and Knights"},
+	{"rc2",               "rc2"MODARCH".so",          "rc2.dll",           "Rocket Crowbar 2"},
+	{"retrocs",           "rcs"MODARCH".so",          "rcs.dll",           "Retro Counter-Strike"},
+	{"rewolf",            "hl"MODARCH".so",           "gunman.dll",        "Gunman Chronicles"},
+	{"ricochet",          "ricochet"MODARCH".so",     "mp.dll",            "Ricochet"},
+	{"rockcrowbar",       "rc"MODARCH".so",           "rc.dll",            "Rocket Crowbar"},
+	{"rspecies",          "hl"MODARCH".so",           "hl.dll",            "Rival Species"},
+	{"scihunt",           "shunt.so",                 "shunt.dll",         "Scientist Hunt"},
+	{"sdmmod",            "sdmmod"MODARCH".so",       "sdmmod.dll",        "Special Death Match"},
+	{"Ship",              "ship"MODARCH".so",         "ship.dll",          "The Ship"},
+	{"si",                "si"MODARCH".so",           "si.dll",            "Science & Industry"},
+	{"snow",              "snow"MODARCH".so",         "snow.dll",          "Snow-War"},
+	{"stargatetc",        "hl"MODARCH".so",           "hl.dll",            "StargateTC"},
+	{"svencoop",          "hl"MODARCH".so",           "hl.dll",            "Sven Coop"},
+	{"swarm",             "swarm"MODARCH".so",        "swarm.dll",         "Swarm"},
+	{"tfc",               "tfc"MODARCH".so",          "tfc.dll",           "Team Fortress Classic"},
+	{"thewastes",         "thewastes"MODARCH".so",    "thewastes.dll",     "The Wastes"},
+	{"timeless",          "pt"MODARCH".so",           "timeless.dll",      "Project Timeless"},
+	{"tod",               "hl"MODARCH".so",           "hl.dll",            "Tour of Duty"},
+	{"trainhunters",      "th"MODARCH".so",           "th.dll",            "Train Hunters"},
+	{"trevenge",          "trevenge.so",              "trevenge.dll",      "The Terrorist Revenge"},
+	{"TS",                "ts"MODARCH".so",           "mp.dll",            "The Specialists"},
+	{"tt",                "tt"MODARCH".so",           "tt.dll",            "The Trenches"},
+	{"underworld",        "uw"MODARCH".so",           "uw.dll",            "Underworld Bloodline"},
+	{"valve",             "hl"MODARCH".so",           "hl.dll",            "Half-Life Deathmatch"},
+	{"vs",                "vs"MODARCH".so",           "mp.dll",            "VampireSlayer"},
+	{"wantedhl",          "hl"MODARCH".so",           "wanted.dll",        "Wanted!"},
+	{"wasteland",         "whl_linux.so",             "mp.dll",            "Wasteland"},
+	{"weapon_wars",       "ww"MODARCH".so",           "hl.dll",            "Weapon Wars"},
+	{"wizwars",           "mp"MODARCH".so",           "hl.dll",            "Wizard Wars"},
+	{"wormshl",           "wormshl_i586.so",          "wormshl.dll",       "WormsHL"},
+	{"zp",                "none",                     "mp.dll",            "Zombie Panic"},
diff --git a/sdk/metamod/h_export.h b/sdk/metamod/h_export.h
new file mode 100644
index 0000000..a9e64a9
--- /dev/null
+++ b/sdk/metamod/h_export.h
@@ -0,0 +1,49 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// h_export.h - prototypes for h_export.cpp
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 H_EXPORT_H
+#define H_EXPORT_H
+
+#include "osdep.h"			// DLLEXPORT, WINAPI, etc
+
+// Our GiveFnptrsToDll, called by engine.
+typedef void (WINAPI *GIVE_ENGINE_FUNCTIONS_FN) (enginefuncs_t 
+		*pengfuncsFromEngine, globalvars_t *pGlobals);
+
+C_DLLEXPORT void WINAPI GiveFnptrsToDll(enginefuncs_t *pengfuncsFromEngine, 
+		globalvars_t *pGlobals);
+
+#endif /* H_EXPORT_H */
diff --git a/sdk/metamod/info_name.h b/sdk/metamod/info_name.h
new file mode 100644
index 0000000..1605cfe
--- /dev/null
+++ b/sdk/metamod/info_name.h
@@ -0,0 +1,56 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// info_name.h - name, desc, author, etc
+
+/*
+ * Copyright (c) 2001-2004 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 INFO_NAME_H
+#define INFO_NAME_H
+
+#include "vers_meta.h"		// VDATE, VVERSION, etc
+
+#define VNAME		"Metamod"
+#define VAUTHOR		"Will Day <willday@metamod.org>"
+#define VURL		"http://www.metamod.org/"
+
+#define COPYRIGHT_YEAR "2006"
+
+// Various strings for the Windows DLL Resources in res_meta.rc
+#define RC_COMMENTS		"Metamod allows running multiple mod-like plugin DLLs, to add functionality or change the behavior of the running HLDS game mod.  See " VURL
+#define RC_DESC			"Metamod Half-Life MOD DLL"
+#define RC_FILENAME		"METAMOD.DLL"
+#define RC_INTERNAL		"METAMOD"
+#define RC_COPYRIGHT	"Copyright� 2001-" COPYRIGHT_YEAR  " Will Day; GPL licensed"
+#define RC_LICENSE      "Licensed under the GNU General Public License"
+
+#endif /* INFO_NAME_H */
diff --git a/sdk/metamod/linkent.h b/sdk/metamod/linkent.h
new file mode 100644
index 0000000..6e17f44
--- /dev/null
+++ b/sdk/metamod/linkent.h
@@ -0,0 +1,117 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// linkent.h - export entities from mod "games" back to the HL engine
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 LINK_ENT_H
+#define LINK_ENT_H
+
+#include <extdll.h>		// always
+
+#include "osdep.h"		// DLLEXPORT, etc
+#include "metamod.h"	// GameDLL, etc
+#include "mlist.h"		// MPluginList::find_match, etc
+#include "mplugin.h"	// MPlugin::info, etc
+#include "log_meta.h"	// META_DEBUG, etc
+
+// Comments from SDK dlls/util.h:
+//! This is the glue that hooks .MAP entity class names to our CPP classes.
+//! The _declspec forces them to be exported by name so we can do a lookup with GetProcAddress().
+//! The function is used to intialize / allocate the object for the entity.
+
+// Adapted from LINK_ENTITY_TO_FUNC in adminmod linkfunc.cpp.
+
+typedef void (*ENTITY_FN) (entvars_t *);
+
+// Function to perform common code of LINK_ENTITY_TO_GAME.
+void do_link_ent(ENTITY_FN *pfnEntity, int *missing, char *entStr, 
+		entvars_t *pev);
+
+#define LINK_ENTITY_TO_GAME(entityName) \
+	C_DLLEXPORT void entityName(entvars_t *pev); \
+	void entityName(entvars_t *pev) { \
+		static ENTITY_FN pfnEntity = NULL; \
+		static int missing=0; \
+		char *entStr; \
+		entStr = STRINGIZE(entityName, 0); \
+		do_link_ent(&pfnEntity, &missing, entStr, pev); \
+	}
+
+// For now, we have to explicitly export functions for plugin entities,
+// just as for gamedll entities.  Ideally, this could be generalized in
+// some manner, so that plugins can declare and use their own entities
+// without having them explicitly supported by metamod, but I don't know
+// yet if that is actually possible.
+//
+// LINK_ENTITY_TO_PLUGIN
+//  - if plugin not loaded & running, return
+//  - plugin has to be set loadable=startup only, else log error, return
+//  - (plugin loaded) if func missing, return
+//  - (plugin loaded) if func not found, dlsym
+//  - (plugin loaded) if func still not found, set missing, return
+//  - (plugin loaded, func found) call func
+#define LINK_ENTITY_TO_PLUGIN(entityName, pluginName) \
+	C_DLLEXPORT void entityName(entvars_t *pev); \
+	void entityName(entvars_t *pev) { \
+		static ENTITY_FN pfnEntity = NULL; \
+		static int missing=0; \
+		char *entStr; \
+		MPlugin *findp; \
+		entStr = STRINGIZE(entityName, 0); \
+		if(missing) \
+			return; \
+		if(!pfnEntity) { \
+			if(!(findp=Plugins->find_match(pluginName))) { \
+				META_ERROR("Couldn't find loaded plugin '%s' for plugin entity '%s'", pluginName, entStr); \
+				missing=1; \
+				return; \
+			} \
+			if(findp->info && findp->info->loadable != PT_STARTUP) { \
+				META_ERROR("Can't link entity '%s' for plugin '%s'; loadable != startup: %s", entStr, pluginName, findp->str_loadable()); \
+				missing=1; \
+				return; \
+			} \
+			META_DEBUG(9, ("Looking up plugin entity '%s'", entStr)); \
+			pfnEntity = (ENTITY_FN) DLSYM(findp->handle, entStr); \
+		} \
+		if(!pfnEntity) { \
+			META_ERROR("Couldn't find plugin entity '%s' in plugin DLL '%s'", entStr, findp->file); \
+			missing=1; \
+			return; \
+		} \
+		META_DEBUG(8, ("Linking plugin entity '%s'", entStr)); \
+		(*pfnEntity)(pev); \
+	}
+
+#endif /* LINK_ENT_H */
diff --git a/sdk/metamod/log_meta.h b/sdk/metamod/log_meta.h
new file mode 100644
index 0000000..d2254ca
--- /dev/null
+++ b/sdk/metamod/log_meta.h
@@ -0,0 +1,102 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// log_meta.h - functions & macros for logging
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 LOG_META_H
+#define LOG_META_H
+
+#include "enginecallbacks.h"	// ALERT, etc
+#include "sdk_util.h"			// UTIL_VarArgs, etc
+
+// Debug logging.  
+//
+// This is done as a macro, rather than a function.  This way, you can add
+// DEBUG statements all over, without worrying about performance
+// implications.  If the debugging level is set low, all those statements
+// will only generate a simple float/int compare each; if we were to use a
+// function instead of a macro, it would end up wasting a lot of cpu cycles
+// calling/returning from the function every time.  With a fair number of
+// DEBUG statements, or if they're placed in frequently excuted code, the
+// overhead of the wasted function calls could significantly impact server
+// performance.
+//
+// For this reason, we also compare directly to the float value of the
+// cvar, rather than calling CVAR_GET_FLOAT() and thus generating a string
+// compare for each DEBUG statement.
+//
+// Called as: 
+//    META_DEBUG(3, ("return code: %d", ret)); 
+//
+// Note the double parens, and the missing parens around "args" in the
+// macro itself.  Note also the "do..while(0)" loop wrapping the
+// statements, so they become a single statement when expanded, necessary
+// for times when it might be called as a single-statement result of an
+// else (or other flow control).
+//
+// As suggested by Jussi Kivilinna: Use "if(meta_debug.value < level); else
+// DO(something);" style because "meta_debug.value < level" is in most common
+// case "false". Check disasm, contitional jumps are predicted not to be
+// taken by CPU.
+//
+// Yes, it's all a bit of a hack.
+
+#define META_DEBUG(level, args) \
+	do { if(meta_debug.value < level) break; else ALERT(at_logged, "[META] (debug:%d) %s\n", level, UTIL_VarArgs args ); } while(0)
+
+// max buffer size for printed messages
+#define MAX_LOGMSG_LEN	1024
+
+// max buffer size for client messages
+#define MAX_CLIENTMSG_LEN 128
+
+extern cvar_t meta_debug;
+
+// META_DEV provides debug logging via the cvar "developer" (when set to 1)
+// and uses a function call rather than a macro as it's really intended to
+// be used only during startup, before meta_debug has been set from reading
+// server.cfg.
+// NOTE: META_DEV has now been mostly obsoleted in the code.
+
+void META_CONS(const char *fmt, ...);
+void META_DEV(const char *fmt, ...);
+void META_INFO(const char *fmt, ...);
+void META_WARNING(const char *fmt, ...);
+void META_ERROR(const char *fmt, ...);
+void META_LOG(const char *fmt, ...);
+void META_CLIENT(edict_t *pEntity, const char *fmt, ...);
+
+void flush_ALERT_buffer(void);
+
+#endif /* LOG_META_H */
diff --git a/sdk/metamod/meta_api.h b/sdk/metamod/meta_api.h
new file mode 100644
index 0000000..c76b129
--- /dev/null
+++ b/sdk/metamod/meta_api.h
@@ -0,0 +1,237 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// meta_api.h - description of metamod's DLL interface
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 META_API_H
+#define META_API_H
+
+#include "dllapi.h"				// GETENTITYAPI_FN, etc
+#include "engine_api.h"			// GET_ENGINE_FUNCTIONS_FN, etc
+#include "plinfo.h"				// plugin_info_t, etc
+#include "mutil.h"				// mutil_funcs_t, etc
+#include "osdep.h"				// DLLEXPORT, etc
+
+// Version consists of "major:minor", two separate integer numbers.
+// Version 1	original
+// Version 2	added plugin_info_t **pinfo
+// Version 3	init split into query and attach, added detach
+// Version 4	added (PLUG_LOADTIME now) to attach
+// Version 5	changed mm ifvers int* to string, moved pl ifvers to info
+// Version 5:1	added link support for entity "adminmod_timer" (adminmod)
+// Version 5:2	added gamedll_funcs to meta_attach() [v1.0-rc2]
+// Version 5:3	added mutil_funcs to meta_query() [v1.05]
+// Version 5:4	added centersay utility functions [v1.06]
+// Version 5:5	added Meta_Init to plugin API [v1.08]
+// Version 5:6	added CallGameEntity utility function [v1.09]
+// Version 5:7	added GetUserMsgID, GetUserMsgName util funcs [v1.11]
+// Version 5:8	added GetPluginPath [v1.11]
+// Version 5:9	added GetGameInfo [v1.14]
+// Version 5:10 added GINFO_REALDLL_FULLPATH for GetGameInfo [v1.17]
+// Version 5:11 added plugin loading and unloading API [v1.18]
+// Version 5:12 added util code for checking player query status [v1.18]
+// Version 5:13 added cvarquery2 support and api for calling hook tables [v1.19]
+#define META_INTERFACE_VERSION "5:13"
+
+#ifdef UNFINISHED
+// Version 5:99	added event hook utility functions [v.???]
+#define META_INTERFACE_VERSION "5:99"
+#endif /* UNFINISHED */
+
+// Flags returned by a plugin's api function.
+// NOTE: order is crucial, as greater/less comparisons are made.
+typedef enum {
+	MRES_UNSET = 0,
+	MRES_IGNORED,		// plugin didn't take any action
+	MRES_HANDLED,		// plugin did something, but real function should still be called
+	MRES_OVERRIDE,		// call real function, but use my return value
+	MRES_SUPERCEDE,		// skip real function; use my return value
+} META_RES;
+
+// Variables provided to plugins.
+typedef struct meta_globals_s {
+	META_RES mres;			// writable; plugin's return flag
+	META_RES prev_mres;		// readable; return flag of the previous plugin called
+	META_RES status;		// readable; "highest" return flag so far
+	void *orig_ret;			// readable; return value from "real" function
+	void *override_ret;		// readable; return value from overriding/superceding plugin
+} meta_globals_t;
+
+extern meta_globals_t *gpMetaGlobals;
+#define SET_META_RESULT(result)			gpMetaGlobals->mres=result
+#define RETURN_META(result) \
+	do { gpMetaGlobals->mres=result; return; } while(0)
+#define RETURN_META_VALUE(result, value) \
+	do { gpMetaGlobals->mres=result; return(value); } while(0)
+#define META_RESULT_STATUS				gpMetaGlobals->status
+#define META_RESULT_PREVIOUS			gpMetaGlobals->prev_mres
+#define META_RESULT_ORIG_RET(type)		*(type *)gpMetaGlobals->orig_ret
+#define META_RESULT_OVERRIDE_RET(type)	*(type *)gpMetaGlobals->override_ret
+
+// Table of getapi functions, retrieved from each plugin.
+typedef struct {
+	GETENTITYAPI_FN         pfnGetEntityAPI;
+	GETENTITYAPI_FN         pfnGetEntityAPI_Post;
+	GETENTITYAPI2_FN        pfnGetEntityAPI2;
+	GETENTITYAPI2_FN        pfnGetEntityAPI2_Post;
+	GETNEWDLLFUNCTIONS_FN   pfnGetNewDLLFunctions;
+	GETNEWDLLFUNCTIONS_FN   pfnGetNewDLLFunctions_Post;
+	GET_ENGINE_FUNCTIONS_FN pfnGetEngineFunctions;
+	GET_ENGINE_FUNCTIONS_FN pfnGetEngineFunctions_Post;
+} META_FUNCTIONS;
+
+// Pair of function tables provided by game DLL.
+typedef struct {
+	DLL_FUNCTIONS *dllapi_table;
+	NEW_DLL_FUNCTIONS *newapi_table;
+} gamedll_funcs_t;
+
+// Declared in plugin; referenced in macros.
+extern gamedll_funcs_t *gpGamedllFuncs;
+extern mutil_funcs_t *gpMetaUtilFuncs;
+
+// Tell the dll that we'll be loading it as a metamod plugin, in case it
+// needs to do something special prior to the standard query/attach
+// procedure.  In particular, this will allow for DLL's that can be used as
+// both standalone DLL's and metamod plugins. (optional; not required in
+// plugin)
+C_DLLEXPORT void Meta_Init(void);
+typedef void (*META_INIT_FN) (void);
+
+// Get info about plugin, compare meta_interface versions, provide meta
+// utility callback functions.
+C_DLLEXPORT int Meta_Query(char *interfaceVersion, 
+		plugin_info_t **plinfo, 
+		mutil_funcs_t *pMetaUtilFuncs);
+typedef int (*META_QUERY_FN) (char *interfaceVersion, 
+		plugin_info_t **plinfo, 
+		mutil_funcs_t *pMetaUtilFuncs);
+
+// Attach the plugin to the API; get the table of getapi functions; give 
+// meta_globals and gamedll_funcs.
+C_DLLEXPORT int Meta_Attach(PLUG_LOADTIME now, 
+		META_FUNCTIONS *pFunctionTable, 
+		meta_globals_t *pMGlobals, 
+		gamedll_funcs_t *pGamedllFuncs);
+typedef int (*META_ATTACH_FN) (PLUG_LOADTIME now, 
+		META_FUNCTIONS *pFunctionTable, 
+		meta_globals_t *pMGlobals, 
+		gamedll_funcs_t *pGamedllFuncs);
+
+// Detach the plugin; tell why and when.
+C_DLLEXPORT int Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
+typedef int (*META_DETACH_FN) (PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
+
+// Standard HL SDK interface function prototypes.
+C_DLLEXPORT int GetEntityAPI_Post(DLL_FUNCTIONS *pFunctionTable, 
+		int interfaceVersion );
+C_DLLEXPORT int GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable, 
+		int *interfaceVersion );
+
+// Additional SDK-like interface function prototypes.
+C_DLLEXPORT int GetNewDLLFunctions_Post(NEW_DLL_FUNCTIONS *pNewFunctionTable, 
+		int *interfaceVersion );
+C_DLLEXPORT int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, 
+		int *interfaceVersion);
+C_DLLEXPORT int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, 
+		int *interfaceVersion);
+
+// Convenience macros for accessing GameDLL functions.  Note: these talk
+// _directly_ to the gamedll, and are not multiplexed through Metamod to
+// the other plugins.
+
+// DLL API functions:
+#define MDLL_FUNC	gpGamedllFuncs->dllapi_table
+
+#define MDLL_GameDLLInit				MDLL_FUNC->pfnGameInit
+#define MDLL_Spawn						MDLL_FUNC->pfnSpawn
+#define MDLL_Think						MDLL_FUNC->pfnThink
+#define MDLL_Use						MDLL_FUNC->pfnUse
+#define MDLL_Touch						MDLL_FUNC->pfnTouch
+#define MDLL_Blocked					MDLL_FUNC->pfnBlocked
+#define MDLL_KeyValue					MDLL_FUNC->pfnKeyValue
+#define MDLL_Save						MDLL_FUNC->pfnSave
+#define MDLL_Restore					MDLL_FUNC->pfnRestore
+#define MDLL_ObjectCollsionBox			MDLL_FUNC->pfnAbsBox
+#define MDLL_SaveWriteFields			MDLL_FUNC->pfnSaveWriteFields
+#define MDLL_SaveReadFields				MDLL_FUNC->pfnSaveReadFields
+#define MDLL_SaveGlobalState			MDLL_FUNC->pfnSaveGlobalState
+#define MDLL_RestoreGlobalState			MDLL_FUNC->pfnRestoreGlobalState
+#define MDLL_ResetGlobalState			MDLL_FUNC->pfnResetGlobalState
+#define MDLL_ClientConnect				MDLL_FUNC->pfnClientConnect
+#define MDLL_ClientDisconnect			MDLL_FUNC->pfnClientDisconnect
+#define MDLL_ClientKill					MDLL_FUNC->pfnClientKill
+#define MDLL_ClientPutInServer			MDLL_FUNC->pfnClientPutInServer
+#define MDLL_ClientCommand				MDLL_FUNC->pfnClientCommand
+#define MDLL_ClientUserInfoChanged		MDLL_FUNC->pfnClientUserInfoChanged
+#define MDLL_ServerActivate				MDLL_FUNC->pfnServerActivate
+#define MDLL_ServerDeactivate			MDLL_FUNC->pfnServerDeactivate
+#define MDLL_PlayerPreThink				MDLL_FUNC->pfnPlayerPreThink
+#define MDLL_PlayerPostThink			MDLL_FUNC->pfnPlayerPostThink
+#define MDLL_StartFrame					MDLL_FUNC->pfnStartFrame
+#define MDLL_ParmsNewLevel				MDLL_FUNC->pfnParmsNewLevel
+#define MDLL_ParmsChangeLevel			MDLL_FUNC->pfnParmsChangeLevel
+#define MDLL_GetGameDescription			MDLL_FUNC->pfnGetGameDescription
+#define MDLL_PlayerCustomization		MDLL_FUNC->pfnPlayerCustomization
+#define MDLL_SpectatorConnect			MDLL_FUNC->pfnSpectatorConnect
+#define MDLL_SpectatorDisconnect		MDLL_FUNC->pfnSpectatorDisconnect
+#define MDLL_SpectatorThink				MDLL_FUNC->pfnSpectatorThink
+#define MDLL_Sys_Error					MDLL_FUNC->pfnSys_Error
+#define MDLL_PM_Move					MDLL_FUNC->pfnPM_Move
+#define MDLL_PM_Init					MDLL_FUNC->pfnPM_Init
+#define MDLL_PM_FindTextureType			MDLL_FUNC->pfnPM_FindTextureType
+#define MDLL_SetupVisibility			MDLL_FUNC->pfnSetupVisibility
+#define MDLL_UpdateClientData			MDLL_FUNC->pfnUpdateClientData
+#define MDLL_AddToFullPack				MDLL_FUNC->pfnAddToFullPack
+#define MDLL_CreateBaseline				MDLL_FUNC->pfnCreateBaseline
+#define MDLL_RegisterEncoders			MDLL_FUNC->pfnRegisterEncoders
+#define MDLL_GetWeaponData				MDLL_FUNC->pfnGetWeaponData
+#define MDLL_CmdStart					MDLL_FUNC->pfnCmdStart
+#define MDLL_CmdEnd						MDLL_FUNC->pfnCmdEnd
+#define MDLL_ConnectionlessPacket		MDLL_FUNC->pfnConnectionlessPacket
+#define MDLL_GetHullBounds				MDLL_FUNC->pfnGetHullBounds
+#define MDLL_CreateInstancedBaselines	MDLL_FUNC->pfnCreateInstancedBaselines
+#define MDLL_InconsistentFile			MDLL_FUNC->pfnInconsistentFile
+#define MDLL_AllowLagCompensation		MDLL_FUNC->pfnAllowLagCompensation
+
+// NEW API functions:
+#define MNEW_FUNC	gpGamedllFuncs->newapi_table
+
+#define MNEW_OnFreeEntPrivateData		MNEW_FUNC->pfnOnFreeEntPrivateData
+#define MNEW_GameShutdown				MNEW_FUNC->pfnGameShutdown
+#define MNEW_ShouldCollide				MNEW_FUNC->pfnShouldCollide
+#define MNEW_CvarValue					MNEW_FUNC->pfnCvarValue
+#define MNEW_CvarValue2					MNEW_FUNC->pfnCvarValue2
+
+#endif /* META_API_H */
diff --git a/sdk/metamod/meta_eiface.h b/sdk/metamod/meta_eiface.h
new file mode 100644
index 0000000..4b804a6
--- /dev/null
+++ b/sdk/metamod/meta_eiface.h
@@ -0,0 +1,478 @@
+
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// meta_eiface.h - wrapper for engine/dll interface
+
+/*
+ * Copyright (c) 2001-2006 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 MM_META_EIFACE_H
+#define MM_META_EIFACE_H
+
+#include <extdll.h>				// NEW_DLL_FUNCTIONS, enginefuncs_t
+#include <string.h>             // memset()
+
+
+// We use our own versions of the engine/dll interface structs. We add a
+// few dummy entries to the end and set them to 0. That way we are
+// protected from updates to the HL SDK adding new functions which would
+// cause a) the game dll copying arbitrary values from us and b) the game
+// dll overwriting our memory when using an old Metamod with a new game
+// dll. 
+
+const int c_NumDummies = 5;
+typedef void (*pdummyfunc)(void);
+
+
+// --------------------------------------------------------------------
+// meta_new_dll_functions_t
+// --------------------------------------------------------------------
+
+struct meta_new_dll_functions_t : public NEW_DLL_FUNCTIONS {
+		// Array of five dummy function pointers. Must be filled with NULL.
+        pdummyfunc dummies[c_NumDummies];
+
+	// functions :
+
+		meta_new_dll_functions_t();
+		meta_new_dll_functions_t(
+            void  (*pfnOnFreeEntPrivateData) (edict_t*),
+            void  (*pfnGameShutdown)         (void),
+            int   (*pfnShouldCollide)        (edict_t*, edict_t*),
+            void  (*pfnCvarValue)            (const edict_t*, const char*),
+            void  (*pfnCvarValue2)           (const edict_t*, int, const char*, const char*)
+        );
+
+        meta_new_dll_functions_t( const meta_new_dll_functions_t& );
+        meta_new_dll_functions_t& operator=( const meta_new_dll_functions_t& );
+
+		// Fill this object with pointers copied from a NEW_DLL_FUNCTIONS struct.
+		void set_from( NEW_DLL_FUNCTIONS* pFuncs );
+
+		// Copy the pointers from this object to a NEW_DLL_FUNCTIONS struct.
+		void copy_to( NEW_DLL_FUNCTIONS* pFuncs );
+
+		// return the engine's version of NEW_DLL_FUNCTIONS
+		int version( void );
+
+
+	private:
+
+	// data :
+
+		// The NEW_DLL_FUNCTIONS struct also changed, but the version
+		// number did not change. That begs the question why to have 
+		// it versioned in the first place, but whaddaya know.
+		// While the official version is left at 1, we internally
+		// calculate a different version of the engine's NEW_DLL_FUNCTIONS
+		// struct since we know that the engine lies to us about the
+		// version that it uses.
+		//
+		// The default version is 1.
+		// 
+		// With the enginefuncs interface version 156 the function
+		// pfnCvarValue() was added, which we call version 2.
+		//
+		// With the enginefuncs interface version 157 the function
+		// pfnCvarValue2() was added, which we call version 3.
+		//
+		// If Valve ever decides to change the version of the
+		// NEW_DLL_FUNCTIONS interface in the future (haha),
+		// we are in trouble and will need to change our
+		// internal versions.
+
+		static int sm_version;	
+
+	// functions :
+
+		// Calculates our idea of the engine's version of the
+		// NEW_DLL_FUNCTIONS interface. Stores this version for future
+		// reference in m_version and returns it.
+		int determine_interface_version( void );
+
+		// Comfort function to determine the size of the NEW_DLL_FUNCTIONS
+		// struct for the different versions.
+		// If passed a version number other than 0, the size for that
+		// specific version is returned. 
+		// If passed 0 as version number (default) the size for the version
+		// that was determined to be the version of the currently connected
+		// engine's interface. Should that version have not yet been
+		// determined (via the enginefuncs_t interface), 0 is returned to
+		// indicated this error state.
+		size_t get_size( int version = 0 );
+};
+
+
+// Inline functions
+
+inline meta_new_dll_functions_t::meta_new_dll_functions_t() 
+{ 
+    memset( this, 0, sizeof(meta_new_dll_functions_t) ); 
+}
+
+
+inline meta_new_dll_functions_t::meta_new_dll_functions_t( const meta_new_dll_functions_t& _rhs )
+{
+	memcpy( this, &_rhs, sizeof(NEW_DLL_FUNCTIONS) );
+    memset( dummies, 0, sizeof(pdummyfunc) * c_NumDummies ); 
+}
+
+
+inline meta_new_dll_functions_t& meta_new_dll_functions_t::operator=( const meta_new_dll_functions_t& _rhs)
+{
+	memcpy( this, &_rhs, sizeof(NEW_DLL_FUNCTIONS) );
+    return *this;
+}
+
+
+inline void meta_new_dll_functions_t::set_from( NEW_DLL_FUNCTIONS* _pFuncs )
+{
+	memcpy( this, _pFuncs, sizeof(NEW_DLL_FUNCTIONS) );
+}
+
+
+inline int meta_new_dll_functions_t::version( void ) 
+{ 
+    return sm_version ? sm_version : determine_interface_version(); 
+}
+
+
+
+// No meta version of DLL_FUNCTIONS because that won't be changing anymore.
+
+
+
+// --------------------------------------------------------------------
+// meta_enginefuncs_t
+// --------------------------------------------------------------------
+
+
+struct meta_enginefuncs_t : public enginefuncs_t {
+    // data :
+
+		// Array of five dummy function pointers. Must be filled with NULL.
+        pdummyfunc dummies[c_NumDummies];
+
+	// functions :
+
+		meta_enginefuncs_t();
+
+        // Spawn of the devil
+        meta_enginefuncs_t(
+            int              (*_pfnPrecacheModel)                   (char*),
+            int              (*_pfnPrecacheSound)                   (char*),
+            void             (*_pfnSetModel)                        (edict_t*, const char*),
+            int              (*_pfnModelIndex)                      (const char*),
+            int              (*_pfnModelFrames)                     (int),
+            void             (*_pfnSetSize)                         (edict_t*, const float*, const float*),
+            void             (*_pfnChangeLevel)                     (char*, char*),
+            void             (*_pfnGetSpawnParms)                   (edict_t*),
+            void             (*_pfnSaveSpawnParms)                  (edict_t*),
+            float            (*_pfnVecToYaw)                        (const float*),
+            void             (*_pfnVecToAngles)                     (const float*, float*),
+            void             (*_pfnMoveToOrigin)                    (edict_t*, const float*, float, int),
+            void             (*_pfnChangeYaw)                       (edict_t*),
+            void             (*_pfnChangePitch)                     (edict_t*),
+            edict_t*         (*_pfnFindEntityByString)              (edict_t*, const char*, const char*),
+            int              (*_pfnGetEntityIllum)                  (edict_t*),
+            edict_t*         (*_pfnFindEntityInSphere)              (edict_t*, const float*, float),
+            edict_t*         (*_pfnFindClientInPVS)                 (edict_t*),
+            edict_t*         (*_pfnEntitiesInPVS)                   (edict_t*),
+            void             (*_pfnMakeVectors)                     (const float*),
+            void             (*_pfnAngleVectors)                    (const float*, float*, float*, float*),
+            edict_t*         (*_pfnCreateEntity)                    (void),
+            void             (*_pfnRemoveEntity)                    (edict_t*),
+            edict_t*         (*_pfnCreateNamedEntity)               (int),
+            void             (*_pfnMakeStatic)                      (edict_t*),
+            int              (*_pfnEntIsOnFloor)                    (edict_t*),
+            int              (*_pfnDropToFloor)                     (edict_t*),
+            int	             (*_pfnWalkMove)                        (edict_t*, float, float, int),
+            void             (*_pfnSetOrigin)                       (edict_t*, const float*),
+            void             (*_pfnEmitSound)                       (edict_t*, int, const char*, float, float, int, int),
+            void             (*_pfnEmitAmbientSound)                (edict_t*, float*, const char*, float, float, int, int),
+            void             (*_pfnTraceLine)                       (const float*, const float*, int, edict_t*, TraceResult*),
+            void             (*_pfnTraceToss)                       (edict_t*, edict_t*, TraceResult*),
+            int	             (*_pfnTraceMonsterHull)                (edict_t*, const float*, const float*, int, edict_t*, TraceResult*),
+            void             (*_pfnTraceHull)                       (const float*, const float*, int, int, edict_t*, TraceResult*),
+            void             (*_pfnTraceModel)                      (const float*, const float*, int, edict_t*, TraceResult*),
+            const char*      (*_pfnTraceTexture)                    (edict_t*, const float*, const float*),
+            void             (*_pfnTraceSphere)                     (const float*, const float*, int, float, edict_t*, TraceResult*),
+            void             (*_pfnGetAimVector)                    (edict_t*, float, float*),
+            void             (*_pfnServerCommand)                   (char*),
+            void             (*_pfnServerExecute)                   (void),
+            void             (*_pfnClientCommand)                   (edict_t*, char*, ...),
+            void             (*_pfnParticleEffect)                  (const float*, const float*, float, float),
+            void             (*_pfnLightStyle)                      (int, char*),
+            int	             (*_pfnDecalIndex)                      (const char*),
+            int              (*_pfnPointContents)                   (const float*),
+            void             (*_pfnMessageBegin)                    (int, int, const float*, edict_t*),
+            void             (*_pfnMessageEnd)                      (void),
+            void             (*_pfnWriteByte)                       (int),
+            void             (*_pfnWriteChar)                       (int),
+            void             (*_pfnWriteShort)                      (int),
+            void             (*_pfnWriteLong)                       (int),
+            void             (*_pfnWriteAngle)                      (float),
+            void             (*_pfnWriteCoord)                      (float),
+            void             (*_pfnWriteString)                     (const char*),
+            void             (*_pfnWriteEntity)                     (int),
+            void             (*_pfnCVarRegister)                    (cvar_t*),
+            float            (*_pfnCVarGetFloat)                    (const char*),
+            const char*      (*_pfnCVarGetString)                   (const char*),
+            void             (*_pfnCVarSetFloat)                    (const char*, float),
+            void             (*_pfnCVarSetString)                   (const char*, const char*),
+            void             (*_pfnAlertMessage)                    (ALERT_TYPE, char*, ...),
+            void             (*_pfnEngineFprintf)                   (void*, char*, ...),
+            void*            (*_pfnPvAllocEntPrivateData)           (edict_t*, int32),
+            void*            (*_pfnPvEntPrivateData)                (edict_t*),
+            void             (*_pfnFreeEntPrivateData)              (edict_t*),
+            const char*      (*_pfnSzFromIndex)                     (int),
+            int              (*_pfnAllocString)	                    (const char*),
+            struct entvars_s*(*_pfnGetVarsOfEnt)                    (edict_t*),
+            edict_t*         (*_pfnPEntityOfEntOffset)              (int),
+            int              (*_pfnEntOffsetOfPEntity)              (const edict_t*),
+            int              (*_pfnIndexOfEdict)                    (const edict_t*),
+            edict_t*         (*_pfnPEntityOfEntIndex)               (int),
+            edict_t*         (*_pfnFindEntityByVars)                (struct entvars_s*),
+            void*            (*_pfnGetModelPtr)                     (edict_t*),
+            int              (*_pfnRegUserMsg)                      (const char*, int),
+            void             (*_pfnAnimationAutomove)               (const edict_t*, float),
+            void             (*_pfnGetBonePosition)                 (const edict_t*, int, float*, float* ),
+            uint32           (*_pfnFunctionFromName)                (const char*),
+            const char*      (*_pfnNameForFunction)                 (uint32),
+            void             (*_pfnClientPrintf)                    (edict_t*, PRINT_TYPE, const char*),
+            void             (*_pfnServerPrint)                     (const char*),
+            const char*      (*_pfnCmd_Args)                        (void),
+            const char*      (*_pfnCmd_Argv)                        (int argc), 
+            int	             (*_pfnCmd_Argc)                        (void),
+            void             (*_pfnGetAttachment)                   (const edict_t*, int, float*, float*),
+            void             (*_pfnCRC32_Init)                      (CRC32_t*),
+            void             (*_pfnCRC32_ProcessBuffer)             (CRC32_t*, void*, int),
+            void             (*_pfnCRC32_ProcessByte)               (CRC32_t*, unsigned char),
+            CRC32_t          (*_pfnCRC32_Final)                     (CRC32_t),
+            int32            (*_pfnRandomLong)                      (int32,  int32),
+            float            (*_pfnRandomFloat)                     (float, float),
+            void             (*_pfnSetView)                         (const edict_t*, const edict_t*),
+            float            (*_pfnTime)                            (void),
+            void             (*_pfnCrosshairAngle)                  (const edict_t*, float, float),
+            byte*            (*_pfnLoadFileForMe)                   (char*, int*),
+            void             (*_pfnFreeFile)                        (void*),
+            void             (*_pfnEndSection)                      (const char*),
+            int              (*_pfnCompareFileTime)                 (char*, char*, int*),
+            void             (*_pfnGetGameDir)                      (char*),
+            void             (*_pfnCvar_RegisterVariable)           (cvar_t*),
+            void             (*_pfnFadeClientVolume)                (const edict_t*, int, int, int, int),
+            void             (*_pfnSetClientMaxspeed)               (const edict_t*, float),
+            edict_t*         (*_pfnCreateFakeClient)                (const char*),
+            void             (*_pfnRunPlayerMove)                   (edict_t*, const float*, float, float, float, unsigned short, byte, byte),
+            int              (*_pfnNumberOfEntities)                (void),
+            char*            (*_pfnGetInfoKeyBuffer)                (edict_t*),
+            char*            (*_pfnInfoKeyValue)                    (char*, char*),
+            void             (*_pfnSetKeyValue)                     (char*, char*, char*),
+            void             (*_pfnSetClientKeyValue)               (int, char*, char*, char*),
+            int              (*_pfnIsMapValid)                      (char*),
+            void             (*_pfnStaticDecal)                     (const float*, int, int, int),
+            int              (*_pfnPrecacheGeneric)                 (char*),
+            int	             (*_pfnGetPlayerUserId)                 (edict_t*),
+            void             (*_pfnBuildSoundMsg)                   (edict_t*, int, const char*, float, float, int, int, int, int, const float*, edict_t*),
+            int              (*_pfnIsDedicatedServer)               (void),
+            cvar_t*          (*_pfnCVarGetPointer)                  (const char*),
+            unsigned int     (*_pfnGetPlayerWONId)                  (edict_t*), 
+            void             (*_pfnInfo_RemoveKey)                  (char*, const char*),
+            const char*      (*_pfnGetPhysicsKeyValue)              (const edict_t*, const char*),
+            void             (*_pfnSetPhysicsKeyValue)              (const edict_t*, const char*, const char*),
+            const char*      (*_pfnGetPhysicsInfoString)            (const edict_t*),
+            unsigned short   (*_pfnPrecacheEvent)                   (int, const char*),
+            void             (*_pfnPlaybackEvent)                   (int, const edict_t*, unsigned short, float, float*, float*, float, float, int, int, int, int),
+            unsigned char*   (*_pfnSetFatPVS)                       (float*),
+            unsigned char*   (*_pfnSetFatPAS)                       (float*),
+            int              (*_pfnCheckVisibility)                 (const edict_t*, unsigned char*),
+            void             (*_pfnDeltaSetField)                   (struct delta_s*, const char*),
+            void             (*_pfnDeltaUnsetField)                 (struct delta_s*, const char*),
+            void             (*_pfnDeltaAddEncoder)                 (char*, void (*)(struct delta_s*, const unsigned char*, const unsigned char*)),
+            int              (*_pfnGetCurrentPlayer)                (void),
+            int              (*_pfnCanSkipPlayer)                   (const edict_t*),
+            int              (*_pfnDeltaFindField)                  (struct delta_s*, const char*),
+            void             (*_pfnDeltaSetFieldByIndex)            (struct delta_s*, int),
+            void             (*_pfnDeltaUnsetFieldByIndex)          (struct delta_s*, int),
+            void             (*_pfnSetGroupMask)                    (int, int),
+            int              (*_pfnCreateInstancedBaseline)         (int, struct entity_state_s*),
+            void             (*_pfnCvar_DirectSet)                  (struct cvar_s*, char*),
+            void             (*_pfnForceUnmodified)                 (FORCE_TYPE, float*, float*, const char*),
+            void             (*_pfnGetPlayerStats)                  (const edict_t*, int*, int*),
+            void             (*_pfnAddServerCommand)                (char*, void (*) (void)),
+            qboolean         (*_pfnVoice_GetClientListening)        (int, int),
+            qboolean         (*_pfnVoice_SetClientListening)        (int, int, qboolean),
+            const char*      (*_pfnGetPlayerAuthId)                 (edict_t*),
+            sequenceEntry_s* (*_pfnSequenceGet)                     (const char*, const char*),
+            sentenceEntry_s* (*_pfnSequencePickSentence)            (const char*, int, int*),
+            int              (*_pfnGetFileSize)                     (char*),
+            unsigned int     (*_pfnGetApproxWavePlayLen)            (const char*),
+            int              (*_pfnIsCareerMatch)                   (void),
+            int              (*_pfnGetLocalizedStringLength)        (const char*),
+            void             (*_pfnRegisterTutorMessageShown)       (int),
+            int              (*_pfnGetTimesTutorMessageShown)       (int),
+            void             (*_pfnProcessTutorMessageDecayBuffer)  (int*, int),
+            void             (*_pfnConstructTutorMessageDecayBuffer)(int*, int),
+            void             (*_pfnResetTutorMessageDecayData)      (void),
+            void             (*_pfnQueryClientCvarValue)            (const edict_t*, const char*),
+            void             (*_pfnQueryClientCvarValue2)           (const edict_t*, const char*, int)
+        );
+
+        meta_enginefuncs_t( const meta_enginefuncs_t& );
+        meta_enginefuncs_t& operator=( const meta_enginefuncs_t& );
+
+		// Fill this object with pointers copied from an enginefuncs_t struct.
+		void set_from( enginefuncs_t *pFuncs );
+
+		// Copy the pointers from this object to an enginefuncs_t struct.
+		void copy_to( enginefuncs_t *pFuncs );
+
+		// return the engine interface version
+		static int version( void );
+
+	protected:
+
+	// data :
+
+		// The version of the engine functions interface. It is frozen at 138. But no one knows
+		// when that was and what it looked like then. So we simply interprete it as the
+		// number of functions that the enginefuncs struct contains.
+		// 
+		// That means we get gaps inbetween versions and right now we can detect only
+		// about five different versions anyway, but that suffices for the current itches
+		// to get scratched.
+		//
+		// The default is hence 138.
+		// A value of 0 means "not yet determined".
+		// Other possible versions currently detectable:
+		// 144: engine versions after 1.1.0.9 build 1996
+        // 147: engine versions after build 2384 with pfnGetFileSize()
+		// 155: all versions between build 2384 and the one 
+		//      including pfnQueryClientCvarValue()
+		// 156: includes pfnQueryClientCvarValue()
+		// 157: includes pfnQueryClientCvarValue2()
+		static int sm_version;	
+
+};
+
+//
+// Inline functions
+//
+
+inline meta_enginefuncs_t::meta_enginefuncs_t() 
+{ 
+    memset( this, 0, sizeof(meta_enginefuncs_t) ); 
+}
+
+
+inline meta_enginefuncs_t::meta_enginefuncs_t( const meta_enginefuncs_t& _rhs )
+{
+	memcpy( this, &_rhs, sizeof(enginefuncs_t) );
+    memset( dummies, 0, sizeof(pdummyfunc) * c_NumDummies ); 
+}
+
+
+inline meta_enginefuncs_t& meta_enginefuncs_t::operator=( const meta_enginefuncs_t& _rhs)
+{
+	memcpy( this, &_rhs, sizeof(enginefuncs_t) );
+    return *this;
+}
+
+
+inline void meta_enginefuncs_t::set_from( enginefuncs_t* _pFuncs )
+{
+	memcpy( this, _pFuncs, sizeof(enginefuncs_t) );
+}
+
+
+inline void meta_enginefuncs_t::copy_to( enginefuncs_t* _pFuncs )
+{
+	memcpy( _pFuncs, this, sizeof(enginefuncs_t) );
+}
+
+
+inline int meta_enginefuncs_t::version( void ) 
+{ 
+    return sm_version; 
+}
+
+
+
+// --------------------------------------------------------------------
+// HL_enginefuncs_t
+// --------------------------------------------------------------------
+
+//
+// This is a specialisation of the meta_enginefuncs_t struct which is only
+// used for the initial copy of the engine functions, i.e. those we get
+// passed from the HL engine right at the beginning. 
+// This specialisation does some extra initialisation when getting set up
+// like calculating the engine interface version and fixing up any invalid
+// pointers.
+// Since there is only one master copy of engine functions this could be
+// implemented as a singleton. This is left as an option for later.
+//
+struct HL_enginefuncs_t : public meta_enginefuncs_t {
+
+	// functions :
+
+		HL_enginefuncs_t() : meta_enginefuncs_t() { };
+
+		// Fill this object with pointers copied from an enginefuncs_t struct
+		// and fixup the interface.
+		// For this class this happens in the GiveFptrsToDll() function
+		// with the pointers passed from the HL engine.
+		void initialise_interface( enginefuncs_t *pFuncs );
+
+
+	private:
+
+	// functions :
+
+		// Moving copy_to() and set_from() to the private space.
+		void set_from( enginefuncs_t *pFuncs ) { meta_enginefuncs_t::set_from( pFuncs ); };
+		void copy_to( enginefuncs_t *pFuncs )  { meta_enginefuncs_t::copy_to( pFuncs ); };
+		
+
+		// Determine the version of the engine interface from the
+		// enginefuncs signature.
+		void determine_engine_interface_version( void );
+
+		// Fixup the enginefuncs pointers according to the determined
+		// version as some pointers may be invalid.
+		void fixup_engine_interface( void );
+};
+
+
+
+#endif /* META_EIFACE_H */
+
diff --git a/sdk/metamod/metamod.h b/sdk/metamod/metamod.h
new file mode 100644
index 0000000..7c4a61f
--- /dev/null
+++ b/sdk/metamod/metamod.h
@@ -0,0 +1,426 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// metamod.h - (main) description of metamod operations
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 METAMOD_H
+#define METAMOD_H
+
+#include "meta_api.h"			// META_RES, etc
+#include "mlist.h"				// MPluginList, etc
+#include "mreg.h"				// MRegCmdList, etc
+#include "conf_meta.h"			// MConfig
+#include "osdep.h"				// NAME_MAX, etc
+#include "types_meta.h"			// mBOOL
+#include "mplayer.h"			// MPlayerList
+#include "meta_eiface.h"        // HL_enginefuncs_t, meta_enginefuncs_t
+#include "engine_t.h"           // engine_t, Engine
+
+// file that lists plugins to load at startup
+#define PLUGINS_INI			"addons/metamod/plugins.ini"
+#define OLD_PLUGINS_INI		"metamod.ini"
+
+// file that contains commands to metamod plugins at startup
+#define EXEC_CFG			"addons/metamod/exec.cfg"
+#define OLD_EXEC_CFG		"metaexec.cfg"
+
+// previously, file that contained path for an override-gamedll
+#define OLD_GAMEDLL_TXT		"metagame.ini"
+
+// generic config file
+#define CONFIG_INI			"addons/metamod/config.ini"
+
+
+// cvar to contain version
+extern cvar_t meta_version;
+
+// Info about the game dll/mod.
+typedef struct gamedll_s {
+	char name[NAME_MAX];		// ie "cstrike" (from gamedir)
+	char *desc;					// ie "Counter-Strike"
+	char gamedir[PATH_MAX];		// ie "/home/willday/half-life/cstrike"
+	char pathname[PATH_MAX];	// ie "/home/willday/half-life/cstrike/dlls/cs_i386.so"
+	char const *file;			// ie "cs_i386.so"
+	char real_pathname[PATH_MAX];	// in case pathname overridden by bot, etc
+	DLHANDLE handle;
+	gamedll_funcs_t funcs;		// dllapi_table, newapi_table
+} gamedll_t;
+extern gamedll_t GameDLL;
+
+// SDK variables for storing engine funcs and globals.
+extern HL_enginefuncs_t g_engfuncs;
+extern globalvars_t  *gpGlobals;
+
+// Our modified version of the engine funcs, to give to plugins.
+extern meta_enginefuncs_t g_plugin_engfuncs;
+
+// Config structure.
+extern MConfig *Config;
+
+// List of plugins loaded/opened/running.
+extern MPluginList *Plugins;
+
+// List of command functions registered by plugins.
+extern MRegCmdList *RegCmds;
+
+// List of cvar structures registered by plugins.
+extern MRegCvarList *RegCvars;
+
+// List of user messages registered by gamedll.
+extern MRegMsgList *RegMsgs;
+
+#ifdef UNFINISHED
+// List of event/logline hooks requested by plugins.
+extern MHookList *Hooks;
+#endif /* UNFINISHED */
+
+// Data provided to plugins.
+// Separate copies to prevent plugins from modifying "readable" parts.
+// See meta_api.h for meta_globals_t structure.
+extern meta_globals_t PublicMetaGlobals;
+extern meta_globals_t PrivateMetaGlobals;
+
+// hook function tables
+extern DLL_FUNCTIONS *pHookedDllFunctions;
+extern NEW_DLL_FUNCTIONS *pHookedNewDllFunctions;
+
+// (patch by hullu)
+// Safety check for metamod-bot-plugin bugfix.
+//  engine_api->pfnRunPlayerMove calls dllapi-functions before it returns.
+//  This causes problems with bots running as metamod plugins, because
+//  metamod assumed that PublicMetaGlobals is free to be used.
+//  With call_count we can fix this by backuping up PublicMetaGlobals if 
+//  it's already being used.
+extern unsigned int CALL_API_count;
+
+// stores previous requestid counter
+extern int requestid_counter;
+
+// (patch by BAILOPAN)
+// Holds cached player info, right now only things for querying cvars
+// Max players is always 32, small enough that we can use a static array
+extern MPlayerList g_Players;
+
+void metamod_startup(void);
+
+mBOOL meta_init_gamedll(void);
+mBOOL meta_load_gamedll(void);
+
+// ===== lotsa macros... ======================================================
+
+// These are the meat of the metamod processing, and are as ugly as (or
+// uglier) than they look.  This is done via macros, because of the varying
+// parameter types (int, void, edict_t*, etc) as well as varying
+// function-pointer types and different api tables (dllapi, newapi,
+// engine), which just can't be passed to a function.  And, since the
+// operation is similar for each api call, I didn't want to keep
+// duplicating code all over the place.  Thus the ugly macros.
+//
+// The basic operation is, for each api call:
+//  - iterate through list of plugins
+//  - for each plugin, if it provides this api call, then call the
+//    function in the plugin
+//  - call the "real" function (in the game dll, or from the engine)
+//  - for each plugin, check for a "post" version of the function, and call
+//    if present
+//
+//
+// Also, for any api call, each plugin has the opportunity to replace the
+// real routine, in two ways:
+//  - prevent the real routine from being called ("supercede")
+//  - allow the real routine to be called, but change the value that's
+//    returned ("override")
+//
+// Thus after each plugin is called, its META_RETURN flag is checked, and
+// action taken appropriately.  Note that supercede/override only affects
+// the _real_ routine; other plugins will still be called.
+//
+// In addition to the SUPERCEDE and OVERRIDE flags, there are two
+// additional flags a plugin can return:
+//  - HANDLED ("I did something here")
+//  - IGNORED ("I didn't really do anything")
+//
+// These aren't used by metamod itself, but could be used by plugins to
+// get an idea if a previous plugin did anything.
+//
+//
+// The 5 basic macros are:
+//   SETUP
+//   CALL_PLUGIN
+//   CALL_GAME  and  CALL_ENGINE
+//   RETURN
+//
+// These 5 are actually used to build second level macros for each api type
+// (dllapi, newapi, engine), with the CALL_PLUGIN macro being used twice
+// (before and after).  Altogether, they end up expanding to approx 150
+// lines of code for _each_ api call.  Ack, ugly indeed.
+//
+// However, due to some functions returning 'void', and others returning an
+// actual value, I had to have separate macros for the two, since I
+// couldn't seem to generalize the two into a form that the compiler would
+// accept.  Thus there are "_void" versions of the 5 macros; these are
+// listed first.
+
+// ===== macros for void-returning functions ==================================
+
+// declare/init some variables
+#define SETUP_API_CALLS_void(FN_TYPE, pfnName, api_info_table) \
+	int i; \
+	META_RES mres=MRES_UNSET, status=MRES_UNSET, prev_mres=MRES_UNSET; \
+	MPlugin *iplug; \
+	FN_TYPE pfn_routine=NULL; \
+	int loglevel=api_info_table.pfnName.loglevel; \
+	char *pfn_string=api_info_table.pfnName.name; \
+	meta_globals_t backup_meta_globals; \
+	/* fix bug with metamod-bot-plugins (hullu)*/ \
+	if (CALL_API_count++>0) \
+		/* backup publicmetaglobals */ \
+		backup_meta_globals = PublicMetaGlobals;
+
+// call each plugin
+#define CALL_PLUGIN_API_void(post, pfnName, pfn_args, api_table) \
+	prev_mres=MRES_UNSET; \
+	for(i=0; i < Plugins->endlist; i++) { \
+		iplug=&Plugins->plist[i]; \
+		if (iplug->status != PL_RUNNING) \
+			continue; \
+		if(iplug->api_table && (pfn_routine=iplug->api_table->pfnName)); \
+		else \
+			/* plugin doesn't provide this function */  \
+			continue; \
+		/* initialize PublicMetaGlobals */ \
+		PublicMetaGlobals.mres = MRES_UNSET; \
+		PublicMetaGlobals.prev_mres = prev_mres; \
+		PublicMetaGlobals.status = status; \
+		/* call plugin */ \
+		META_DEBUG(loglevel, ("Calling %s:%s%s()", iplug->file, pfn_string, (post?"_Post":""))); \
+		pfn_routine pfn_args; \
+		/* plugin's result code */ \
+		mres=PublicMetaGlobals.mres; \
+		if(mres > status) \
+			status = mres; \
+		/* save this for successive plugins to see */ \
+		prev_mres = mres; \
+		if(mres==MRES_UNSET) \
+			META_ERROR("Plugin didn't set meta_result: %s:%s%s()", iplug->file, pfn_string, (post?"_Post":"")); \
+		if(post && mres==MRES_SUPERCEDE) \
+			META_ERROR("MRES_SUPERCEDE not valid in Post functions: %s:%s%s()", iplug->file, pfn_string, (post?"_Post":"")); \
+	}
+
+// call "real" function, from gamedll
+#define CALL_GAME_API_void(pfnName, pfn_args, api_table) \
+	CALL_API_count--; \
+	if(status==MRES_SUPERCEDE) { \
+		META_DEBUG(loglevel, ("Skipped (supercede) %s:%s()", GameDLL.file, pfn_string)); \
+		/* don't return here; superceded game routine, but still allow \
+		 * _post routines to run. \
+		 */ \
+	} \
+	else if(GameDLL.funcs.api_table) { \
+		pfn_routine=GameDLL.funcs.api_table->pfnName; \
+		if(pfn_routine) { \
+			META_DEBUG(loglevel, ("Calling %s:%s()", GameDLL.file, pfn_string)); \
+			pfn_routine pfn_args; \
+		} \
+		/* don't complain for NULL routines in NEW_DLL_FUNCTIONS  */ \
+		else if((void*) GameDLL.funcs.api_table != (void*) GameDLL.funcs.newapi_table) { \
+			META_ERROR("Couldn't find api call: %s:%s", GameDLL.file, pfn_string); \
+			status=MRES_UNSET; \
+		} \
+	} \
+	else { \
+		META_DEBUG(loglevel, ("No api table defined for api call: %s:%s", GameDLL.file, pfn_string)); \
+	} \
+	CALL_API_count++;
+
+// call "real" function, from engine
+#define CALL_ENGINE_API_void(pfnName, pfn_args) \
+	CALL_API_count--; \
+	if(status==MRES_SUPERCEDE) { \
+		META_DEBUG(loglevel, ("Skipped (supercede) engine:%s()", pfn_string)); \
+		/* don't return here; superceded game routine, but still allow \
+		 * _post routines to run. \
+		 */ \
+	} \
+	else { \
+		pfn_routine=Engine.funcs->pfnName; \
+		if(pfn_routine) { \
+			META_DEBUG(loglevel, ("Calling engine:%s()", pfn_string)); \
+			pfn_routine pfn_args; \
+		} \
+		else { \
+			META_ERROR("Couldn't find api call: engine:%s", pfn_string); \
+			status=MRES_UNSET; \
+		} \
+	} \
+	CALL_API_count++;
+
+// return (void)
+#define RETURN_API_void() \
+	if (--CALL_API_count>0) \
+		/*restore backup*/ \
+		PublicMetaGlobals = backup_meta_globals; \
+	return;
+
+
+// ===== macros for type-returning functions ==================================
+
+// declare/init some variables
+#define SETUP_API_CALLS(ret_t, ret_init, FN_TYPE, pfnName, api_info_table) \
+	int i; \
+	ret_t dllret=ret_init; \
+	ret_t override_ret=ret_init; \
+	ret_t pub_override_ret=ret_init; \
+	ret_t orig_ret=ret_init; \
+	ret_t pub_orig_ret=ret_init; \
+	META_RES mres=MRES_UNSET, status=MRES_UNSET, prev_mres=MRES_UNSET; \
+	MPlugin *iplug; \
+	FN_TYPE pfn_routine=NULL; \
+	int loglevel=api_info_table.pfnName.loglevel; \
+	char *pfn_string=api_info_table.pfnName.name; \
+	meta_globals_t backup_meta_globals; \
+	/*Fix bug with metamod-bot-plugins*/ \
+	if (CALL_API_count++>0) \
+		/*Backup PublicMetaGlobals*/ \
+		backup_meta_globals = PublicMetaGlobals;
+
+// call each plugin
+#define CALL_PLUGIN_API(post, ret_init, pfnName, pfn_args, MRES_TYPE, api_table) \
+	override_ret=ret_init; \
+	prev_mres=MRES_UNSET; \
+	for(i=0; i < Plugins->endlist; i++) { \
+		if (Plugins->plist[i].status != PL_RUNNING) \
+			continue; \
+		iplug=&Plugins->plist[i]; \
+		if(iplug->api_table && (pfn_routine=iplug->api_table->pfnName)); \
+		else \
+			/* plugin doesn't provide this function */  \
+			continue; \
+		/* initialize PublicMetaGlobals */ \
+		PublicMetaGlobals.mres = MRES_UNSET; \
+		PublicMetaGlobals.prev_mres = prev_mres; \
+		PublicMetaGlobals.status = status; \
+		pub_orig_ret = orig_ret; \
+		PublicMetaGlobals.orig_ret = &pub_orig_ret; \
+		if(status==MRES_TYPE) { \
+			pub_override_ret = override_ret; \
+			PublicMetaGlobals.override_ret = &pub_override_ret; \
+		} \
+		/* call plugin */ \
+		META_DEBUG(loglevel, ("Calling %s:%s%s()", iplug->file, pfn_string, (post?"_Post":""))); \
+		dllret=pfn_routine pfn_args; \
+		/* plugin's result code */ \
+		mres=PublicMetaGlobals.mres; \
+		if(mres > status) \
+			status = mres; \
+		/* save this for successive plugins to see */ \
+		prev_mres = mres; \
+		if(mres==MRES_TYPE) \
+			override_ret = pub_override_ret = dllret; \
+		else if(mres==MRES_UNSET) \
+			META_ERROR("Plugin didn't set meta_result: %s:%s%s()", iplug->file, pfn_string, (post?"_Post":"")); \
+		else if(post && mres==MRES_SUPERCEDE) \
+			META_ERROR("MRES_SUPERCEDE not valid in Post functions: %s:%s%s()", iplug->file, pfn_string, (post?"_Post":"")); \
+	}
+
+// call "real" function, from gamedll
+#define CALL_GAME_API(pfnName, pfn_args, api_table) \
+	CALL_API_count--; \
+	if(status==MRES_SUPERCEDE) { \
+		META_DEBUG(loglevel, ("Skipped (supercede) %s:%s()", GameDLL.file, pfn_string)); \
+		orig_ret = pub_orig_ret = override_ret; \
+		PublicMetaGlobals.orig_ret = &pub_orig_ret; \
+		/* don't return here; superceded game routine, but still allow \
+		 * _post routines to run. \
+		 */ \
+	} \
+	else if(GameDLL.funcs.api_table) { \
+		pfn_routine=GameDLL.funcs.api_table->pfnName; \
+		if(pfn_routine) { \
+			META_DEBUG(loglevel, ("Calling %s:%s()", GameDLL.file, pfn_string)); \
+			dllret=pfn_routine pfn_args; \
+			orig_ret = dllret; \
+		} \
+		/* don't complain for NULL routines in NEW_DLL_FUNCTIONS  */ \
+		else if((void*) GameDLL.funcs.api_table != (void*) GameDLL.funcs.newapi_table) { \
+			META_ERROR("Couldn't find api call: %s:%s", GameDLL.file, pfn_string); \
+			status=MRES_UNSET; \
+		} \
+	} \
+	else { \
+		META_DEBUG(loglevel, ("No api table defined for api call: %s:%s", GameDLL.file, pfn_string)); \
+	} \
+	CALL_API_count++;
+
+// call "real" function, from engine
+#define CALL_ENGINE_API(pfnName, pfn_args) \
+	CALL_API_count--; \
+	if(status==MRES_SUPERCEDE) { \
+		META_DEBUG(loglevel, ("Skipped (supercede) engine:%s()", pfn_string)); \
+		orig_ret = pub_orig_ret = override_ret; \
+		PublicMetaGlobals.orig_ret = &pub_orig_ret; \
+		/* don't return here; superceded game routine, but still allow \
+		 * _post routines to run. \
+		 */ \
+	} \
+	else { \
+		pfn_routine=Engine.funcs->pfnName; \
+		if(pfn_routine) { \
+			META_DEBUG(loglevel, ("Calling engine:%s()", pfn_string)); \
+			dllret=pfn_routine pfn_args; \
+			orig_ret = dllret; \
+		} \
+		else { \
+			META_ERROR("Couldn't find api call: engine:%s", pfn_string); \
+			status=MRES_UNSET; \
+		} \
+	} \
+	CALL_API_count++;
+
+// return a value
+#define RETURN_API() \
+	if (--CALL_API_count>0) \
+		/*Restore backup*/ \
+		PublicMetaGlobals = backup_meta_globals; \
+	if(status==MRES_OVERRIDE) { \
+		META_DEBUG(loglevel, ("Returning (override) %s()", pfn_string)); \
+		return(override_ret); \
+	} \
+	else \
+		return(orig_ret);
+
+// ===== end macros ===========================================================
+
+
+#endif /* METAMOD_H */
diff --git a/sdk/metamod/mhook.h b/sdk/metamod/mhook.h
new file mode 100644
index 0000000..e87a644
--- /dev/null
+++ b/sdk/metamod/mhook.h
@@ -0,0 +1,160 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+#ifdef UNFINISHED
+
+// mhook.h - class and types to describe hooks and hooklists
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 MHOOK_H
+#define MHOOK_H
+
+#include "plinfo.h"			// plid_t, etc
+#include "types_meta.h"		// mBOOL
+#include "osdep.h"			// MUTEX_T, etc
+
+#define MAX_HOOKS	100
+
+// Particular game events that we detect, though whatever means we can best
+// find.
+typedef enum {
+	EV_NONE = 0,			// no event here...
+	// non-log detected
+	EV_PLAYER_CONNECT,		// ie ClientConnect
+	EV_PLAYER_ENTER,		// ie ClientPutInServer
+	EV_PLAYER_LEAVE,		// ie ClientDisconnect (opposite PutInServer)
+	EV_PLAYER_SPAWN,		// deadflag change to DEAD_NO
+	EV_PLAYER_DEATH,		// deadflag change to DEAD_DEAD
+	EV_PLAYER_CHANGE_NAME,	// netname change in ClientUserInfoChanged
+	// log detected
+	EV_PLAYER_JOIN_TEAM,	// ie "Joe<15><785><>" joined team "CT"
+	EV_PLAYER_SUICIDE,		// ie "Joe<15><785><CT>" committed suicide ...
+	EV_PLAYER_CHANGE_ROLE,	// TFC: ie "Joe<15><785><Red>" changed role to "Pyro"
+	EV_TEAM_KILL,			// ie "Joe<15><785><CT>" killed "Bob<16><342><CT>" ...
+	EV_WEAPON_KILL,			// ie "Joe<15><785><CT>" killed "Sam<17><197><TERRORIST>" with "sg552"
+	EV_TEAM_SCORE,			// ie Team "CT" scored "7" with "2" players
+} game_event_t;
+
+// Info corresponding to a player, in particular the info found in the logline.
+typedef struct {
+	char *name;
+	int userid;
+	int wonid;
+	char *team;
+} event_player_t;
+
+// Info for an event, mostly corresponding to info from a logline.
+typedef struct {
+	game_event_t evtype;	// specific event, if identified.
+	char *buf;				// copy of the logmsg, with embedded NULLs
+	event_player_t *player;	
+	char *action;			// "triggered" string, or a generic action string
+	event_player_t *target;
+	char *with;
+} event_args_t;
+
+// Types for callback functions to be called for requested event/logline.
+typedef		void (*event_func_t)	(game_event_t event, event_args_t *args, 
+		const char *logline);
+typedef		void (*logmatch_func_t)	(const char *pattern, event_args_t *args, 
+		const char *logline);
+
+// The 4 types of hook requests we accept.
+typedef enum {
+	H_NONE = 0,
+	H_EVENT,				// Specific event, from a short list.
+	H_TRIGGER,				// A given "triggered" string.
+	H_STRING,				// Any substring of logline.
+	H_REGEX,				// A regular expression matching of logline.
+} hook_t;
+
+
+// Class for individual hook function, as registered by a plugin.
+class MHook {
+	friend class MHookList;
+	friend class MFuncQueue;
+	private:
+	// data:
+		int index;
+		hook_t type;			// EVENT, TRIGGER, etc
+		plid_t plid;
+		int pl_index;			// index of matching plugin
+		void *pfnHandle;
+		game_event_t event;		// if type is H_EVENT
+		const char *match;		// if type is TRIGGER, STRING, or REGEX
+	// Copy/Assignment constructors, to satisfy -Weffc++.
+	// Note however, we declare them private and don't define them, since
+	// we don't ever want to copy or assign instances of the class.
+	// (thanks to O'Reilly "C++: The Core Language", page 113)
+		MHook(const MHook &src);
+		void operator=(const MHook &src);
+	// constructors:
+		MHook(void);
+		MHook(int idx, plid_t pid, game_event_t evt, event_func_t pfn);
+		MHook(int idx, plid_t pid, hook_t tp, const char *cp, logmatch_func_t pfn);
+	// functions:
+		mBOOL call(event_args_t *args, const char *logline);
+		mBOOL enqueue(MFuncQueue *mfq, event_args_t *args, const char *logline);
+	public:
+		// no public interfaces; everything done from friend MHookList.
+};
+
+
+// Class for list of registered hook functions.
+class MHookList {
+	private:
+	// data:
+		MHook *hlist[MAX_HOOKS];
+		int size;			// set to MAX_HOOKS in constructor
+		int endlist;
+		MUTEX_T mx_hlist;
+		int MXlock(void) { return(MUTEX_LOCK(&mx_hlist)); };
+		int MXunlock(void) { return(MUTEX_UNLOCK(&mx_hlist)); };
+	public:
+	// constructor:
+		MHookList(void);
+	// functions:
+		int add(plid_t plid, game_event_t event, event_func_t pfnHandle);
+		int add(plid_t plid, hook_t type, const char *match, 
+				logmatch_func_t pfnHandle);
+		mBOOL remove(plid_t plid, int hindex);
+		int remove_all(plid_t plid);
+		mBOOL call(event_args_t *args, const char *logline);
+		mBOOL enqueue(MFuncQueue *mfq, hook_t htype, event_args_t *evargs, 
+				const char *logline);
+		char *str_htype(hook_t htype);
+};
+
+#endif /* MHOOK_H */
+
+#endif /* UNFINISHED */
diff --git a/sdk/metamod/mlist.h b/sdk/metamod/mlist.h
new file mode 100644
index 0000000..e997fe4
--- /dev/null
+++ b/sdk/metamod/mlist.h
@@ -0,0 +1,90 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// mlist.h - class and constants to describe a list of plugins
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 MLIST_H
+#define MLIST_H
+
+#include "types_meta.h"		// mBOOL
+#include "mplugin.h"		// class MPlugin
+#include "plinfo.h"			// plid_t, etc
+
+// Max number of plugins we can manage.  This is an arbitrary, fixed number,
+// for convenience.  It would probably be better to dynamically grow the
+// list as needed, but we do this for now.
+#define MAX_PLUGINS 50
+// Width required to printf above MAX, for show() functions.
+#define WIDTH_MAX_PLUGINS	2
+
+
+// A list of plugins.
+class MPluginList {
+	public:
+	// data:
+		char inifile[PATH_MAX];				// full pathname
+		MPlugin plist[MAX_PLUGINS];			// array of plugins
+		int size;							// size of list, ie MAX_PLUGINS
+		int endlist;						// index of last used entry
+
+	// constructor:
+		MPluginList(const char *ifile);
+
+	// functions:
+		MPlugin *find(int pindex);			// find by index
+		MPlugin *find(const char *findpath); // find by pathname
+		MPlugin *find(plid_t id);			// find by plid_t
+		MPlugin *find_memloc(void *memptr);	// find by memory location
+		MPlugin *find_match(const char *prefix);	// find by partial prefix match
+		MPlugin *find_match(MPlugin *pmatch);	// find by platform_match()
+		MPlugin * find(DLHANDLE handle);		// find by handle
+		MPlugin *add(MPlugin *padd);
+
+		mBOOL found_child_plugins(int source_index);
+
+		mBOOL ini_startup(void);			// read inifile at startup
+		mBOOL ini_refresh(void);			// re-read inifile
+		mBOOL cmd_addload(const char *args);	// load from console command
+		MPlugin *plugin_addload(plid_t plid, const char *fname, PLUG_LOADTIME now); //load from plugin
+
+		mBOOL load(void);					// load the list, at startup
+		mBOOL refresh(PLUG_LOADTIME now);	// update from re-read inifile
+		void unpause_all(void);				// unpause any paused plugins
+		void retry_all(PLUG_LOADTIME now);	// retry any pending plugin actions
+		void show(int source_index);		// list plugins to console
+		void show_client(edict_t *pEntity);	// list plugins to player client
+		void clear_source_plugin_index(int source_index);
+};
+
+#endif /* MLIST_H */
diff --git a/sdk/metamod/mplayer.h b/sdk/metamod/mplayer.h
new file mode 100644
index 0000000..931bab4
--- /dev/null
+++ b/sdk/metamod/mplayer.h
@@ -0,0 +1,91 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// mplayer.h - class to keep info about a player and a class listing all
+//             players
+
+/*
+ * Copyright (c) 2005 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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_METAMOD_PLAYER_H
+#define INCLUDE_METAMOD_PLAYER_H
+
+#include "types_meta.h"    // mBOOL
+
+
+
+// Numbers of players limit set by the engine
+#define MAX_PLAYERS 32
+
+
+
+// Info on an individual player
+class MPlayer
+{
+private:
+	mBOOL isQueried;                         // is this player currently queried for a cvar value
+	char *cvarName;                          // name of the cvar if getting queried
+
+	MPlayer (const MPlayer&);
+	MPlayer& operator=(const MPlayer&); 
+
+
+public:
+	MPlayer();
+	~MPlayer();
+	void        set_cvar_query(const char *cvar);            // mark this player as querying a client cvar
+	void        clear_cvar_query(const char *cvar=NULL);     // unmark this player as querying a client cvar
+	const char *is_querying_cvar(void);                      // check if a player is querying a cvar. returns
+	                                                         //   NULL if not or the name of the cvar
+};
+
+
+
+// A list of players. The number of max players is fixed and small enough
+// to use an array.
+class MPlayerList
+{
+private:
+	enum { NUM_SLOTS = MAX_PLAYERS + 1 };
+
+	MPlayer players[NUM_SLOTS];              // array of players
+
+	
+public:
+	void        set_player_cvar_query(const edict_t *pEntity, const char *cvar);
+	void        clear_player_cvar_query(const edict_t *pEntity, const char *cvar=NULL);
+	void        clear_all_cvar_queries(void);
+	const char *is_querying_cvar(const edict_t *pEntity);
+};
+
+
+#endif /* INCLUDE_METAMOD_PLAYER_H */ 
+
diff --git a/sdk/metamod/mplugin.h b/sdk/metamod/mplugin.h
new file mode 100644
index 0000000..e04e68f
--- /dev/null
+++ b/sdk/metamod/mplugin.h
@@ -0,0 +1,422 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// mplugin.h - class and types to describe an individual plugin
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 MPLUGIN_H
+#define MPLUGIN_H
+
+#include <time.h>			// time_t, etc
+
+#include <eiface.h>			// DLL_FUNCTIONS, etc
+
+#include "types_meta.h"		// mBOOL
+#include "meta_api.h"		// GETENTITYAPI_FN, etc
+#include "api_info.h"		// dllapi_info, etc
+#include "support_meta.h"	// MAX_DESC_LEN
+
+
+// Flags to indicate current "load" state of plugin.
+// NOTE: order is important, as greater/less comparisons are made.
+typedef enum {
+	PL_EMPTY = 0,		// empty slot
+	PL_VALID,			// has valid info in it
+	PL_BADFILE,			// nonexistent file (open failed), 
+						//    or not a valid plugin file (query failed)
+	PL_OPENED,			// dlopened and queried
+	PL_FAILED,			// opened, but failed to attach or unattach
+	PL_RUNNING,			// attached and running
+	PL_PAUSED,			// attached but paused
+} PLUG_STATUS;
+
+// Action to take for plugin at next opportunity.
+typedef enum {
+	PA_NULL = 0,
+	PA_NONE,			// no action needed right now
+	PA_KEEP,			// keep, after ini refresh
+	PA_LOAD,			// load (dlopen, query) and try to attach
+	PA_ATTACH,			// attach
+	PA_UNLOAD,			// unload (detach, dlclose)
+	PA_RELOAD,			// unload and load again
+} PLUG_ACTION;
+
+// Flags to indicate from where the plugin was loaded.
+typedef enum {
+	PS_INI = 0,			// was loaded from the plugins.ini
+	PS_CMD,				// was loaded via a server command
+	PS_PLUGIN,			// was loaded via a plugin
+} PLOAD_SOURCE;
+
+// Flags for how to word description of plugin loadtime.
+typedef enum {
+	SL_SIMPLE = 0,		// single word
+	SL_SHOW,			// for "show" output, 5 chars
+	SL_ALLOWED,			// when plugin is allowed to load/unload
+	SL_NOW,				// current situation
+} STR_LOADTIME;
+
+// Flags for how to format description of status.
+typedef enum {
+	ST_SIMPLE = 0,		// single word
+	ST_SHOW,			// for "show" output, 4 chars
+} STR_STATUS;
+
+// Flags for how to format description of action.
+typedef enum {
+	SA_SIMPLE = 0,		// single word
+	SA_SHOW,			// for "show" output, 4 chars
+} STR_ACTION;
+
+// Flags for how to format description of source.
+typedef enum {
+	SO_SIMPLE = 0,		// two words
+	SO_SHOW,			// for "list" output, 3 chars
+} STR_SOURCE;
+
+// An individual plugin.
+class MPlugin {
+	private:
+		mBOOL query(void);
+		mBOOL attach(PLUG_LOADTIME now);
+		mBOOL detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
+		gamedll_funcs_t gamedll_funcs;
+		mutil_funcs_t mutil_funcs;
+	public:
+	// data:
+		int index;							// 1-based
+		char filename[PATH_MAX];			// ie "dlls/mm_test_i386.so", from inifile
+		char *file;							// ie "mm_test_i386.so", ptr from filename
+		char desc[MAX_DESC_LEN];			// ie "Test metamod plugin", from inifile
+		char pathname[PATH_MAX];	// UNIQUE, ie "/home/willday/half-life/cstrike/dlls/mm_test_i386.so", built with GameDLL.gamedir
+		int pfspecific;                     // level of specific platform affinity, used during load time
+		PLUG_STATUS status;					// current status of plugin (loaded, etc)
+		PLUG_ACTION action;					// what to do with plugin (load, unload, etc)
+		PLOAD_SOURCE source;				// source of the request to load the plugin
+
+		DLHANDLE handle;					// handle for dlopen, dlsym, etc
+		plugin_info_t *info;				// information plugin provides about itself
+		time_t time_loaded;					// when plugin was loaded
+		int source_plugin_index;			// who loaded this plugin
+		int unloader_index;
+		mBOOL is_unloader;				// fix to prevent other plugins unload active unloader.
+
+		DLL_FUNCTIONS *dllapi_table;
+		DLL_FUNCTIONS *dllapi_post_table;
+		NEW_DLL_FUNCTIONS *newapi_table;
+		NEW_DLL_FUNCTIONS *newapi_post_table;
+		enginefuncs_t *engine_table;
+		enginefuncs_t *engine_post_table;
+
+	// functions:
+		
+		mBOOL ini_parseline(char *line);	// parse line from inifile
+		mBOOL cmd_parseline(const char *line);	// parse from console command
+		mBOOL plugin_parseline(const char *fname, int loader_index); // parse from plugin
+		mBOOL check_input(void);
+
+		mBOOL resolve(void);				// find a matching file on disk
+		char *resolve_dirs(char *path);
+		char *resolve_prefix(char *path);
+		char *resolve_suffix(char *path);
+
+		mBOOL platform_match(MPlugin* plugin);
+		
+		mBOOL load(PLUG_LOADTIME now);
+		mBOOL unload(PLUG_LOADTIME now, PL_UNLOAD_REASON reason, PL_UNLOAD_REASON real_reason);
+		mBOOL reload(PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
+		mBOOL pause(void);
+		mBOOL unpause(void);
+		mBOOL retry(PLUG_LOADTIME now, PL_UNLOAD_REASON reason);	// if previously failed
+		mBOOL clear(void);
+		mBOOL plugin_unload(plid_t plid, PLUG_LOADTIME now, PL_UNLOAD_REASON reason); // other plugin unloading
+		void show(void);					// print info about plugin to console
+
+		mBOOL newer_file(void);				// check for newer file on disk
+
+	// output string functions
+		char *str_status(STR_STATUS fmt);
+		char *str_action(STR_ACTION fmt);
+		char *str_source(STR_SOURCE fmt);
+
+		char *str_reason(PL_UNLOAD_REASON preason, PL_UNLOAD_REASON preal_reason);
+		char *str_loadtime(PLUG_LOADTIME pallow, STR_LOADTIME fmt);
+
+		char *str_status(void)		{ return(str_status(ST_SIMPLE)); };
+		char *str_action(void)		{ return(str_action(SA_SIMPLE)); };
+		char *str_source(void)		{ return(str_source(SO_SIMPLE)); };
+
+		char *str_loadable(void) { 
+			if(info) return(str_loadtime(info->loadable, SL_SIMPLE)); 
+			else return(" -");
+		};
+		char *str_unloadable(void) { 
+			if(info) return(str_loadtime(info->unloadable, SL_SIMPLE)); 
+			else return(" -");
+		};
+		char *str_loadable(STR_LOADTIME fmt) { 
+			if(info) return(str_loadtime(info->loadable, fmt)); 
+			else return(" -");
+		};
+		char *str_unloadable(STR_LOADTIME fmt) { 
+			if(info) return(str_loadtime(info->unloadable, fmt)); 
+			else return(" -");
+		};
+};
+
+// Macros used by MPlugin::show(), to list the functions that the plugin
+// catches.
+#define SHOW_IFDEF(api_table, info_table, pfnName, pre_str, post_str) \
+	if(api_table->pfnName) { META_CONS("%s%s%s", pre_str, info_table.pfnName.name, post_str); n++;}
+
+#define SHOW_DEF_DLLAPI(api_table, pre_str, post_str) \
+	n=0; \
+	SHOW_IFDEF(api_table, dllapi_info, pfnGameInit, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSpawn, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnThink, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnUse, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnTouch, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnBlocked, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnKeyValue, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSave, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnRestore, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSetAbsBox, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSaveWriteFields, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSaveReadFields, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSaveGlobalState, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnRestoreGlobalState, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnResetGlobalState, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnClientConnect, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnClientDisconnect, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnClientKill, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnClientPutInServer, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnClientCommand, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnClientUserInfoChanged,	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnServerActivate, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnServerDeactivate, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnPlayerPreThink, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnPlayerPostThink, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnStartFrame, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnParmsNewLevel, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnParmsChangeLevel, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnGetGameDescription, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnPlayerCustomization, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSpectatorConnect, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSpectatorDisconnect, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSpectatorThink, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSys_Error, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnPM_Move, 				pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnPM_Init, 				pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnPM_FindTextureType, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnSetupVisibility, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnUpdateClientData, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnAddToFullPack, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnCreateBaseline, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnRegisterEncoders, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnGetWeaponData, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnCmdStart, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnCmdEnd, 				pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnConnectionlessPacket, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnGetHullBounds, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnCreateInstancedBaselines, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnInconsistentFile, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, dllapi_info, pfnAllowLagCompensation, 		pre_str, post_str);
+
+#define SHOW_DEF_NEWAPI(api_table, pre_str, post_str) \
+	n=0; \
+	SHOW_IFDEF(api_table, newapi_info, pfnOnFreeEntPrivateData,	pre_str, post_str); \
+	SHOW_IFDEF(api_table, newapi_info, pfnGameShutdown,		pre_str, post_str); \
+	SHOW_IFDEF(api_table, newapi_info, pfnShouldCollide,	pre_str, post_str); \
+	SHOW_IFDEF(api_table, newapi_info, pfnCvarValue,		pre_str, post_str);
+
+#define SHOW_DEF_ENGINE(api_table, pre_str, post_str) \
+	n=0; \
+	SHOW_IFDEF(api_table, engine_info, pfnPrecacheModel, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnPrecacheSound, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetModel, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnModelIndex, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnModelFrames, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetSize, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnChangeLevel, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetSpawnParms, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSaveSpawnParms, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnVecToYaw, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnVecToAngles, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnMoveToOrigin, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnChangeYaw, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnChangePitch, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnFindEntityByString, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetEntityIllum, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnFindEntityInSphere, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnFindClientInPVS, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnEntitiesInPVS, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnMakeVectors, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnAngleVectors, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCreateEntity, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnRemoveEntity, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCreateNamedEntity, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnMakeStatic, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnEntIsOnFloor, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnDropToFloor, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnWalkMove, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetOrigin, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnEmitSound, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnEmitAmbientSound, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnTraceLine, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnTraceToss, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnTraceMonsterHull, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnTraceHull, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnTraceModel, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnTraceTexture, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnTraceSphere, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetAimVector, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnServerCommand, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnServerExecute, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnClientCommand, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnParticleEffect, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnLightStyle, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnDecalIndex, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnPointContents, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnMessageBegin, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnMessageEnd, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnWriteByte, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnWriteChar, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnWriteShort, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnWriteLong, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnWriteAngle, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnWriteCoord, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnWriteString, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnWriteEntity, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCVarRegister, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCVarGetFloat, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCVarGetString, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCVarSetFloat, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCVarSetString, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnAlertMessage, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnEngineFprintf, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnPvAllocEntPrivateData, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnPvEntPrivateData, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnFreeEntPrivateData, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSzFromIndex, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnAllocString, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetVarsOfEnt, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnPEntityOfEntOffset, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnEntOffsetOfPEntity, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnIndexOfEdict, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnPEntityOfEntIndex, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnFindEntityByVars, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetModelPtr, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnRegUserMsg, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnAnimationAutomove, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetBonePosition, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnFunctionFromName, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnNameForFunction, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnClientPrintf, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnServerPrint, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCmd_Args, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCmd_Argv, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCmd_Argc, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetAttachment, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCRC32_Init, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCRC32_ProcessBuffer, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCRC32_ProcessByte, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCRC32_Final, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnRandomLong, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnRandomFloat, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetView, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnTime, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCrosshairAngle, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnLoadFileForMe, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnFreeFile, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnEndSection, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCompareFileTime, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetGameDir, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCvar_RegisterVariable, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnFadeClientVolume, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetClientMaxspeed, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCreateFakeClient, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnRunPlayerMove, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnNumberOfEntities, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetInfoKeyBuffer, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnInfoKeyValue, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetKeyValue, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetClientKeyValue, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnIsMapValid, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnStaticDecal, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnPrecacheGeneric, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetPlayerUserId, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnBuildSoundMsg, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnIsDedicatedServer, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCVarGetPointer, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetPlayerWONId, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnInfo_RemoveKey, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetPhysicsKeyValue, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetPhysicsKeyValue, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetPhysicsInfoString,		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnPrecacheEvent, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnPlaybackEvent, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetFatPVS, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetFatPAS, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCheckVisibility, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnDeltaSetField, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnDeltaUnsetField, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnDeltaAddEncoder, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetCurrentPlayer, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCanSkipPlayer, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnDeltaFindField, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnDeltaSetFieldByIndex, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnDeltaUnsetFieldByIndex, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSetGroupMask, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCreateInstancedBaseline, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnCvar_DirectSet, 			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnForceUnmodified, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetPlayerStats, 		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnAddServerCommand, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnVoice_GetClientListening, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnVoice_SetClientListening, 	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetPlayerAuthId,			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSequenceGet,				pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnSequencePickSentence,		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetFileSize,				pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetApproxWavePlayLen,		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnIsCareerMatch,			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetLocalizedStringLength,			pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnRegisterTutorMessageShown,		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnGetTimesTutorMessageShown,		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnProcessTutorMessageDecayBuffer,	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnConstructTutorMessageDecayBuffer,	pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnResetTutorMessageDecayData,		pre_str, post_str); \
+	SHOW_IFDEF(api_table, engine_info, pfnQueryClientCvarValue,				pre_str, post_str);
+
+
+#endif /* MPLUGIN_H */
diff --git a/sdk/metamod/mqueue.h b/sdk/metamod/mqueue.h
new file mode 100644
index 0000000..39eb991
--- /dev/null
+++ b/sdk/metamod/mqueue.h
@@ -0,0 +1,68 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+#ifdef UNFINISHED
+
+// mqueue.h - class and types for queues
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 MQUEUE_H
+#define MQUEUE_H
+
+#include "plinfo.h"			// plid_t, etc
+#include "tqueue.h"			// templates Queue<>, QItem<>, etc
+#include "mhook.h"			// event_args_t, etc
+#include "types_meta.h"		// mBOOL
+#include "osdep.h"			// MUTEX_T, etc
+
+// Our queue types.
+typedef Queue<const char>	MLogmsgQueue;
+
+typedef struct {
+	MHook *hook;
+	event_args_t *evargs;
+	const char *logline;
+} func_item_t;
+
+class MFuncQueue : public Queue<func_item_t> {
+	public:
+	// renamed constructors:
+		MFuncQueue(void) :Queue<func_item_t>() { };
+		MFuncQueue(int qmaxsize) :Queue<func_item_t>(qmaxsize) { };
+	// added functions:
+		void remove(plid_t plid);
+};
+
+#endif /* MQUEUE_H */
+
+#endif /* UNFINISHED */
diff --git a/sdk/metamod/mreg.h b/sdk/metamod/mreg.h
new file mode 100644
index 0000000..e1c720b
--- /dev/null
+++ b/sdk/metamod/mreg.h
@@ -0,0 +1,186 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// mreg.h - description of registered items (classes MRegCmd, MRegCmdList)
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 MREG_H
+#define MREG_H
+
+#include "types_meta.h"		// mBOOL
+
+// Number of entries to add to reglists when they need to grow.  Typically
+// more cvars than commands, so we grow them at different increments.
+#define REG_CMD_GROWSIZE	32
+#define REG_CVAR_GROWSIZE	64
+
+// Width required to printf a Reg*List index number, for show() functions.
+// This used to correspond to the number of digits in MAX_REG, which was a
+// fixed, compile-time limit.  However, now that the reg lists are grown
+// dynamically, this has less strong correspondance to list sizes.  So for
+// the moment, it reflects what one might normally expect to be the max
+// width needed to print an index number; 4 allows 9999 (which is a damn
+// lot, if you ask me).
+#define WIDTH_MAX_REG	4
+
+// Max number of registered user msgs we can manage.
+#define MAX_REG_MSGS	256
+
+// Flags to indicate if given cvar or func is part of a loaded plugin.
+typedef enum {
+	RG_INVALID,
+	RG_VALID,
+} REG_STATUS;
+
+// Pointer to function registered by AddServerCommand.
+typedef void (*REG_CMD_FN) (void);
+
+
+// An individual registered function/command.
+class MRegCmd {
+	friend class MRegCmdList;
+	private:
+	// data:
+		int index;				// 1-based
+	public:
+		char *name;				// space is malloc'd
+		REG_CMD_FN pfnCmd;		// pointer to the function
+		int plugid;				// index id of corresponding plugin
+		REG_STATUS status;		// whether corresponding plugin is loaded
+	// functions:
+		void init(int idx);		// init values, as not using constructors
+		mBOOL call(void);		// try to call the function
+};
+
+
+// A list of registered commands.
+class MRegCmdList {
+	private:
+	// data:
+		MRegCmd *mlist;			// malloc'd array of registered commands
+		int size;				// current size of list
+		int endlist;			// index of last used entry
+		// Private; to satisfy -Weffc++ "has pointer data members but does
+		// not override" copy/assignment constructor.
+		void operator=(const MRegCmdList &src);
+		MRegCmdList(const MRegCmdList &src);
+
+	public:
+	// constructor:
+		MRegCmdList(void);
+
+	// functions:
+		MRegCmd *find(const char *findname);	// find by MRegCmd->name
+		MRegCmd *add(const char *addname);
+		void disable(int plugin_id);			// change status to Invalid
+		void show(void);						// list all funcs to console
+		void show(int plugin_id);				// list given plugin's funcs to console
+};
+
+
+
+// An individual registered cvar.
+class MRegCvar {
+	friend class MRegCvarList;
+	private:
+	// data:
+		int index;				// 1-based
+	public:
+		cvar_t *data;			// actual cvar structure, malloc'd
+		int plugid;				// index id of corresponding plugin
+		REG_STATUS status;		// whether corresponding plugin is loaded
+	// functions:
+		void init(int idx);		// init values, as not using constructors
+		mBOOL set(cvar_t *src);
+};
+
+
+// A list of registered cvars.
+class MRegCvarList {
+	private:
+	// data:
+		MRegCvar *vlist;		// malloc'd array of registered cvars
+		int size;				// size of list, ie MAX_REG_CVARS
+		int endlist;			// index of last used entry
+		// Private; to satisfy -Weffc++ "has pointer data members but does
+		// not override" copy/assignment constructor.
+		void operator=(const MRegCvarList &src);
+		MRegCvarList(const MRegCvarList &src);
+
+	public:
+	// constructor:
+		MRegCvarList(void);
+
+	// functions:
+		MRegCvar *add(const char *addname);
+		MRegCvar *find(const char *findname);	// find by MRegCvar->data.name
+		void disable(int plugin_id);			// change status to Invalid
+		void show(void);						// list all cvars to console
+		void show(int plugin_id);				// list given plugin's cvars to console
+};
+
+
+
+// An individual registered user msg, from gamedll.
+class MRegMsg {
+	friend class MRegMsgList;
+	private:
+	// data:
+		int index;				// 1-based
+	public:
+		const char *name;		// name, assumed constant string in gamedll
+		int msgid;				// msgid, assigned by engine
+		int size;				// size, if given by gamedll
+};
+
+
+// A list of registered user msgs.
+class MRegMsgList {
+	private:
+	// data:
+		MRegMsg mlist[MAX_REG_MSGS];	// array of registered msgs
+		int size;						// size of list, ie MAX_REG_MSGS
+		int endlist;					// index of last used entry
+
+	public:
+	// constructor:
+		MRegMsgList(void);
+
+	// functions:
+		MRegMsg *add(const char *addname, int addmsgid, int addsize);
+		MRegMsg *find(const char *findname);
+		MRegMsg *find(int findmsgid);
+		void show(void);						// list all msgs to console
+};
+
+#endif /* MREG_H */
diff --git a/sdk/metamod/mutil.h b/sdk/metamod/mutil.h
new file mode 100644
index 0000000..820851b
--- /dev/null
+++ b/sdk/metamod/mutil.h
@@ -0,0 +1,160 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// mutil.h - prototypes for utility functions to provide to plugins
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 MUTIL_H
+#define MUTIL_H
+
+#include "plinfo.h"		// plugin_info_t, etc
+#include "mhook.h"		// game_event_t, etc
+#include "sdk_util.h"	// hudtextparms_t, etc
+
+// max buffer size for printed messages
+#define MAX_LOGMSG_LEN  1024
+
+// For GetGameInfo:
+typedef enum {
+	GINFO_NAME = 0,
+	GINFO_DESC,
+	GINFO_GAMEDIR,
+	GINFO_DLL_FULLPATH,
+	GINFO_DLL_FILENAME,
+	GINFO_REALDLL_FULLPATH,
+} ginfo_t;
+
+// Meta Utility Function table type.
+typedef struct meta_util_funcs_s {
+	void		(*pfnLogConsole)		(plid_t plid, const char *fmt, ...);
+	void		(*pfnLogMessage)		(plid_t plid, const char *fmt, ...);
+	void		(*pfnLogError)			(plid_t plid, const char *fmt, ...);
+	void		(*pfnLogDeveloper)		(plid_t plid, const char *fmt, ...);
+	void		(*pfnCenterSay)			(plid_t plid, const char *fmt, ...);
+	void		(*pfnCenterSayParms)	(plid_t plid, hudtextparms_t tparms, 
+											const char *fmt, ...);
+	void		(*pfnCenterSayVarargs)	(plid_t plid, hudtextparms_t tparms, 
+											const char *fmt, va_list ap);
+	qboolean	(*pfnCallGameEntity)	(plid_t plid, const char *entStr,
+											entvars_t *pev);
+	int			(*pfnGetUserMsgID)		(plid_t plid, const char *msgname, int *size);
+	const char *(*pfnGetUserMsgName)	(plid_t plid, int msgid, int *size);
+	const char *(*pfnGetPluginPath)		(plid_t plid);
+	const char *(*pfnGetGameInfo)		(plid_t plid, ginfo_t tag);
+	int 		(*pfnLoadPlugin)		(plid_t plid, const char *cmdline, PLUG_LOADTIME now, void **plugin_handle);
+	int			(*pfnUnloadPlugin)		(plid_t plid, const char *cmdline, PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
+	int			(*pfnUnloadPluginByHandle) (plid_t plid, void *plugin_handle, PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
+	const char *(*pfnIsQueryingClientCvar) (plid_t plid, const edict_t *pEdict);
+	int			(*pfnMakeRequestId)		(plid_t plid);
+	void		(*pfnGetHookTables)		(plid_t plid, enginefuncs_t **peng, DLL_FUNCTIONS **pdll, NEW_DLL_FUNCTIONS **pnewdll);
+#ifdef UNFINISHED
+	int			(*pfnHookGameEvent)		(plid_t plid, game_event_t event, 
+											event_func_t pfnHandle);
+	int			(*pfnHookLogTrigger)	(plid_t plid, const char *trigger, 
+											logmatch_func_t pfnHandle);
+	int			(*pfnHookLogString)		(plid_t plid, const char *string, 
+											logmatch_func_t pfnHandle);
+	int			(*pfnHookLogRegex)		(plid_t plid, const char *pattern, 
+											logmatch_func_t pfnHandle);
+	qboolean	(*pfnRemoveHookID)		(plid_t plid, int hookid);
+	int			(*pfnRemoveHookAll)		(plid_t plid);
+#endif /* UNFINISHED */
+} mutil_funcs_t;
+extern mutil_funcs_t MetaUtilFunctions;
+
+// Meta Utility Functions
+void mutil_LogConsole(plid_t plid, const char *fmt, ...);
+void mutil_LogMessage(plid_t plid, const char *fmt, ...);
+void mutil_LogError(plid_t plid, const char *fmt, ...);
+void mutil_LogDeveloper(plid_t plid, const char *fmt, ...);
+
+void mutil_CenterSay(plid_t plid, const char *fmt, ...);
+void mutil_CenterSayParms(plid_t plid, hudtextparms_t tparms, 
+		const char *fmt, ...);
+void mutil_CenterSayVarargs(plid_t plid, hudtextparms_t tparms, 
+		const char *fmt, va_list ap);
+
+qboolean mutil_CallGameEntity(plid_t plid, const char *entStr, entvars_t *pev);
+
+int mutil_GetUserMsgID(plid_t plid, const char *name, int *size);
+const char *mutil_GetUserMsgName(plid_t plid, int msgid, int *size);
+const char *mutil_GetPluginPath(plid_t plid);
+const char *mutil_GetGameInfo(plid_t plid, ginfo_t tag);
+const char *mutil_IsQueryingClientCvar(plid_t plid, const edict_t *pEdict);
+int mutil_MakeRequestId(plid_t plid);
+void mutil_GetHookTables(plid_t plid, enginefuncs_t **peng, DLL_FUNCTIONS **pdll, NEW_DLL_FUNCTIONS **pnewdll);
+
+#ifdef UNFINISHED
+int mutil_HookGameEvent(plid_t plid, game_event_t event, 
+		event_func_t pfnHandle);
+int mutil_HookLogTrigger(plid_t plid, const char *trigger, 
+		logmatch_func_t pfnHandle);
+int mutil_HookLogString(plid_t plid, const char *string, 
+		logmatch_func_t pfnHandle);
+int mutil_HookLogRegex(plid_t plid, const char *pattern, 
+		logmatch_func_t pfnHandle);
+
+qboolean mutil_RemoveHookID(plid_t plid, int hookid);
+int mutil_RemoveHookAll(plid_t plid);
+#endif /* UNFINISHED */
+
+// Convenience macros for MetaUtil functions
+#define LOG_CONSOLE			(*gpMetaUtilFuncs->pfnLogConsole)
+#define LOG_MESSAGE			(*gpMetaUtilFuncs->pfnLogMessage)
+#define LOG_ERROR			(*gpMetaUtilFuncs->pfnLogError)
+#define LOG_DEVELOPER		(*gpMetaUtilFuncs->pfnLogDeveloper)
+#define CENTER_SAY			(*gpMetaUtilFuncs->pfnCenterSay)
+#define CENTER_SAY_PARMS	(*gpMetaUtilFuncs->pfnCenterSayParms)
+#define CENTER_SAY_VARARGS	(*gpMetaUtilFuncs->pfnCenterSayVarargs)
+#define CALL_GAME_ENTITY	(*gpMetaUtilFuncs->pfnCallGameEntity)
+#define GET_USER_MSG_ID		(*gpMetaUtilFuncs->pfnGetUserMsgID)
+#define GET_USER_MSG_NAME	(*gpMetaUtilFuncs->pfnGetUserMsgName)
+#define GET_PLUGIN_PATH		(*gpMetaUtilFuncs->pfnGetPluginPath)
+#define GET_GAME_INFO		(*gpMetaUtilFuncs->pfnGetGameInfo)
+#define LOAD_PLUGIN			(*gpMetaUtilFuncs->pfnLoadPlugin)
+#define UNLOAD_PLUGIN		(*gpMetaUtilFuncs->pfnUnloadPlugin)
+#define UNLOAD_PLUGIN_BY_HANDLE (*gpMetaUtilFuncs->pfnUnloadPluginByHandle)
+#define IS_QUERYING_CLIENT_CVAR (*gpMetaUtilFuncs->pfnIsQueryingClientCvar)
+#define MAKE_REQUESTID		(*gpMetaUtilFuncs->pfnMakeRequestId)
+#define GET_HOOK_TABLES		(*gpMetaUtilFuncs->pfnGetHookTables)
+
+#ifdef UNFINISHED
+#define HOOK_GAME_EVENT		(*gpMetaUtilFuncs->pfnHookGameEvent)
+#define HOOK_LOG_TRIGGER	(*gpMetaUtilFuncs->pfnHookLogTrigger)
+#define HOOK_LOG_STRING		(*gpMetaUtilFuncs->pfnHookLogString)
+#define HOOK_LOG_REGEX		(*gpMetaUtilFuncs->pfnHookLogRegex)
+#define REMOVE_HOOK_ID		(*gpMetaUtilFuncs->pfnRemoveHookID)
+#define REMOVE_HOOK_ALL		(*gpMetaUtilFuncs->pfnRemoveHookAll)
+#endif /* UNFINISHED */
+
+#endif /* MUTIL_H */
diff --git a/sdk/metamod/osdep.h b/sdk/metamod/osdep.h
new file mode 100644
index 0000000..32dc8db
--- /dev/null
+++ b/sdk/metamod/osdep.h
@@ -0,0 +1,522 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// osdep.h - operating system dependencies
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 OSDEP_H
+#define OSDEP_H
+
+#include <string.h>			// strerror()
+#include <ctype.h>			// isupper, tolower
+#include <errno.h>			// errno
+
+// Various differences between WIN32 and Linux.
+
+#include "types_meta.h"		// mBOOL
+#include "mreg.h"			// REG_CMD_FN, etc
+#include "log_meta.h"		// LOG_ERROR, etc
+
+extern mBOOL dlclose_handle_invalid;
+
+// String describing platform/DLL-type, for matching lines in plugins.ini.
+#ifdef linux
+	#define PLATFORM		"linux"
+#  ifdef __amd64__
+	#define PLATFORM_SPC	"lin64"
+#  else
+	#define PLATFORM_SPC	"lin32"
+#  endif
+#elif defined(_WIN32)
+	#define PLATFORM		"mswin"
+	#define PLATFORM_SPC	"win32"
+#else /* unknown */
+	#error "OS unrecognized"
+#endif /* unknown */
+
+
+// Macro for function-exporting from DLL..
+// from SDK dlls/cbase.h:
+//! C functions for external declarations that call the appropriate C++ methods
+
+// Windows uses "__declspec(dllexport)" to mark functions in the DLL that
+// should be visible/callable externally.
+//
+// It also apparently requires WINAPI for GiveFnptrsToDll().
+//
+// See doc/notes_windows_coding for more information..
+
+// Attributes to specify an "exported" function, visible from outside the
+// DLL.
+#undef DLLEXPORT
+#ifdef _WIN32
+	#define DLLEXPORT	__declspec(dllexport)
+	// WINAPI should be provided in the windows compiler headers.
+	// It's usually defined to something like "__stdcall".
+#elif defined(linux)
+	#define DLLEXPORT	/* */
+	#define WINAPI		/* */
+#endif /* linux */
+
+#ifdef __GNUC__
+#   define DECLSPEC(kw)
+#   define ATTRIBUTE(kw) __attribute__((kw))
+#   define MM_CDECL
+#elif defined(_MSC_VER)
+#   define DECLSPEC(kw) __declspec(kw)
+#   define ATTRIBUTE(kw)
+#   define MM_CDECL __cdecl
+#endif /* _MSC_VER */
+
+
+// Simplified macro for declaring/defining exported DLL functions.  They
+// need to be 'extern "C"' so that the C++ compiler enforces parameter
+// type-matching, rather than considering routines with mis-matched
+// arguments/types to be overloaded functions...
+//
+// AFAIK, this is os-independent, but it's included here in osdep.h where
+// DLLEXPORT is defined, for convenience.
+#define C_DLLEXPORT		extern "C" DLLEXPORT
+
+
+#ifdef _MSC_VER
+	// Disable MSVC warning:
+	//    4390 : empty controlled statement found; is this what was intended?
+	// generated by the RETURN macros.
+	#pragma warning(disable: 4390)
+#endif /* _MSC_VER */
+
+
+// Functions & types for DLL open/close/etc operations.
+#ifdef linux
+	#include <dlfcn.h>
+	typedef void* DLHANDLE;
+	typedef void* DLFUNC;
+	inline DLHANDLE DLOPEN(const char *filename) {
+		return(dlopen(filename, RTLD_NOW));
+	}
+	inline DLFUNC DLSYM(DLHANDLE handle, const char *string) {
+		return(dlsym(handle, string));
+	}
+	inline int DLCLOSE(DLHANDLE handle) {
+		if (!handle) {
+			dlclose_handle_invalid = mTRUE;
+			return(1);
+		}
+		dlclose_handle_invalid = mFALSE;
+		return(dlclose(handle));
+	}
+	inline const char* DLERROR(void) {
+		if (dlclose_handle_invalid)
+			return("Invalid handle.");
+		return(dlerror());
+	}
+#elif defined(_WIN32)
+	typedef HINSTANCE DLHANDLE;
+	typedef FARPROC DLFUNC;
+	inline DLHANDLE DLOPEN(const char *filename) {
+		return(LoadLibrary(filename));
+	}
+	inline DLFUNC DLSYM(DLHANDLE handle, const char *string) {
+		return(GetProcAddress(handle, string));
+	}
+	inline int DLCLOSE(DLHANDLE handle) {
+		if (!handle) {
+			dlclose_handle_invalid = mTRUE;
+			return(1);
+		}
+		dlclose_handle_invalid = mFALSE;
+		// NOTE: Windows FreeLibrary returns success=nonzero, fail=zero,
+		// which is the opposite of the unix convention, thus the '!'.
+		return(!FreeLibrary(handle));
+	}
+	// Windows doesn't provide a function corresponding to dlerror(), so
+	// we make our own.
+	char *str_GetLastError(void);
+	inline char* DLERROR(void) {
+		if (dlclose_handle_invalid)
+			return("Invalid handle.");
+		return(str_GetLastError());
+	}
+#endif /* _WIN32 */
+const char *DLFNAME(void *memptr);
+mBOOL IS_VALID_PTR(void *memptr);
+
+
+// Attempt to call the given function pointer, without segfaulting.
+mBOOL os_safe_call(REG_CMD_FN pfn);
+
+
+// Windows doesn't have an strtok_r() routine, so we write our own.
+#ifdef _WIN32
+	#define strtok_r(s, delim, ptrptr)	my_strtok_r(s, delim, ptrptr)
+	char *my_strtok_r(char *s, const char *delim, char **ptrptr);
+#endif /* _WIN32 */
+
+
+// Set filename and pathname maximum lengths.  Note some windows compilers
+// provide a <limits.h> which is incomplete and/or causes problems; see
+// doc/windows_notes.txt for more information.
+//
+// Note that both OS's include room for null-termination:
+//   linux:    "# chars in a path name including nul"
+//   win32:    "note that the sizes include space for 0-terminator"
+#ifdef linux
+	#include <limits.h>
+#elif defined(_WIN32)
+	#include <stdlib.h>
+	#define NAME_MAX	_MAX_FNAME
+	#define PATH_MAX	_MAX_PATH
+#endif /* _WIN32 */
+
+
+// Various other windows routine differences.
+#ifdef linux
+	#include <unistd.h>	// sleep
+	#ifndef O_BINARY
+    	#define O_BINARY 0
+	#endif	
+#elif defined(_WIN32)
+	#define snprintf	_snprintf
+	#define vsnprintf	_vsnprintf
+	#define sleep(x)	Sleep(x*1000)
+	#define strcasecmp	_stricmp
+	#define strncasecmp	_strnicmp
+    #include <io.h>
+    #define open _open
+    #define read _read
+    #define write _write
+    #define close _close
+#endif /* _WIN32 */
+
+#ifdef __GNUC__
+	#include <unistd.h>	// getcwd
+#elif defined(_MSC_VER)
+	#include <direct.h>	// getcwd
+#endif /* _MSC_VER */
+
+#include <sys/stat.h>
+#ifndef S_ISREG
+	// Linux gcc defines this; earlier mingw didn't, later mingw does;
+	// MSVC doesn't seem to.
+	#define S_ISREG(m)	((m) & S_IFREG)
+#endif /* not S_ISREG */
+#ifdef _WIN32
+	// The following two are defined in mingw but not in MSVC
+    #ifndef S_IRUSR
+        #define S_IRUSR _S_IREAD
+    #endif
+    #ifndef S_IWUSR
+        #define S_IWUSR _S_IWRITE
+    #endif
+	
+	// The following two are defined neither in mingw nor in MSVC
+    #ifndef S_IRGRP
+        #define S_IRGRP S_IRUSR
+    #endif
+    #ifndef S_IWGRP
+        #define S_IWGRP S_IWUSR
+    #endif
+#endif /* _WIN32 */
+
+
+// Our handler for new().
+//
+// Thanks to notes from:
+//    http://dragon.klte.hu/~kollarl/C++/node45.html
+//
+// At one point it appeared MSVC++ was no longer different from gcc, according 
+// to:
+//    http://msdn.microsoft.com/library/en-us/vclang98/stdlib/info/NEW.asp
+//
+// However, this page is apparently no longer available from MSDN.  The
+// only thing now is:
+//    http://msdn.microsoft.com/library/en-us/vccore98/HTML/_crt_malloc.asp
+//
+// According to Fritz Elfert <felfert@to.com>:
+//    set_new_handler() is just a stub which (according to comments in the
+//    MSVCRT debugging sources) should never be used. It is just an ugly
+//    hack to make STL compile. It does _not_ set the new handler but
+//    always calls _set_new_handler(0) instead. _set_new_handler is the
+//    "real" function and uses the "old" semantic; handler-type is: 
+//       int newhandler(size_t)
+//
+#if defined(__GNUC__) || (defined(_MSC_VER) && (_MSC_VER >= 1300))
+	void MM_CDECL meta_new_handler(void);
+#elif defined(_MSC_VER)
+	int meta_new_handler(size_t size);
+#endif /* _MSC_VER */
+
+
+// To keep the rest of the sources clean and keep not only OS but also
+// compiler dependant differences in this file, we define a local function
+// to set the new handler.
+void mm_set_new_handler( void );
+
+
+
+// Thread handling...
+#ifdef linux
+	#include <pthread.h>
+	typedef	pthread_t 	THREAD_T;
+	// returns 0==success, non-zero==failure
+	inline int THREAD_CREATE(THREAD_T *tid, void (*func)(void)) {
+		int ret;
+		ret=pthread_create(tid, NULL, (void *(*)(void*)) func, NULL);
+		if(ret != 0) {
+			META_ERROR("Failure starting thread: %s", strerror(ret));
+			return(ret);
+		}
+		ret=pthread_detach(*tid);
+		if(ret != 0)
+			META_ERROR("Failure detaching thread: %s", strerror(ret));
+		return(ret);
+	}
+#elif defined(_WIN32)
+	// See:
+	//    http://msdn.microsoft.com/library/en-us/dllproc/prothred_4084.asp
+	typedef	DWORD 		THREAD_T;
+	// returns 0==success, non-zero==failure
+	inline int THREAD_CREATE(THREAD_T *tid, void (*func)(void)) {
+		HANDLE ret;
+		// win32 returns NULL==failure, non-NULL==success
+		ret=CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) func, NULL, 0, tid);
+		if(ret==NULL)
+			META_ERROR("Failure starting thread: %s", str_GetLastError());
+		return(ret==NULL);
+	}
+#endif /* _WIN32 */
+#define THREAD_OK	0
+
+
+// Mutex handling...
+#ifdef linux
+	typedef pthread_mutex_t		MUTEX_T;
+	inline int MUTEX_INIT(MUTEX_T *mutex) {
+		int ret;
+		ret=pthread_mutex_init(mutex, NULL);
+		if(ret!=THREAD_OK)
+			META_ERROR("mutex_init failed: %s", strerror(ret));
+		return(ret);
+	}
+	inline int MUTEX_LOCK(MUTEX_T *mutex) {
+		int ret;
+		ret=pthread_mutex_lock(mutex);
+		if(ret!=THREAD_OK)
+			META_ERROR("mutex_lock failed: %s", strerror(ret));
+		return(ret);
+	}
+	inline int MUTEX_UNLOCK(MUTEX_T *mutex) {
+		int ret;
+		ret=pthread_mutex_unlock(mutex);
+		if(ret!=THREAD_OK)
+			META_ERROR("mutex_unlock failed: %s", strerror(ret));
+		return(ret);
+	}
+#elif defined(_WIN32)
+	// Win32 has "mutexes" as well, but CS's are simpler.
+	// See:
+	//    http://msdn.microsoft.com/library/en-us/dllproc/synchro_2a2b.asp
+	typedef CRITICAL_SECTION	MUTEX_T;
+	// Note win32 routines don't return any error (return void).
+	inline int MUTEX_INIT(MUTEX_T *mutex) {
+		InitializeCriticalSection(mutex);
+		return(THREAD_OK);
+	}
+	inline int MUTEX_LOCK(MUTEX_T *mutex) {
+		EnterCriticalSection(mutex);
+		return(THREAD_OK);
+	}
+	inline int MUTEX_UNLOCK(MUTEX_T *mutex) {
+		LeaveCriticalSection(mutex);
+		return(THREAD_OK);
+	}
+#endif /* _WIN32 (mutex) */
+
+
+// Condition variables...
+#ifdef linux
+	typedef pthread_cond_t	COND_T;
+	inline int COND_INIT(COND_T *cond) {
+		int ret;
+		ret=pthread_cond_init(cond, NULL);
+		if(ret!=THREAD_OK)
+			META_ERROR("cond_init failed: %s", strerror(ret));
+		return(ret);
+	}
+	inline int COND_WAIT(COND_T *cond, MUTEX_T *mutex) {
+		int ret;
+		ret=pthread_cond_wait(cond, mutex);
+		if(ret!=THREAD_OK)
+			META_ERROR("cond_wait failed: %s", strerror(ret));
+		return(ret);
+	}
+	inline int COND_SIGNAL(COND_T *cond) {
+		int ret;
+		ret=pthread_cond_signal(cond);
+		if(ret!=THREAD_OK)
+			META_ERROR("cond_signal failed: %s", strerror(ret));
+		return(ret);
+	}
+#elif defined(_WIN32)
+	// Since win32 doesn't provide condition-variables, we have to model
+	// them with mutex/critical-sections and win32 events.  This uses the
+	// second (SetEvent) solution from:
+	//
+	//    http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
+	//
+	// but without the waiters_count overhead, since we don't need
+	// broadcast functionality anyway.  Or actually, I guess it's more like
+	// the first (PulseEvent) solution, but with SetEven rather than
+	// PulseEvent. :)
+	//
+	// See also:
+	//    http://msdn.microsoft.com/library/en-us/dllproc/synchro_8ann.asp
+	typedef HANDLE COND_T; 
+	inline int COND_INIT(COND_T *cond) {
+		*cond = CreateEvent(NULL,	// security attributes (none)
+							FALSE,	// manual-reset type (false==auto-reset)
+							FALSE,	// initial state (unsignaled)
+							NULL);	// object name (unnamed)
+		// returns NULL on error
+		if(*cond==NULL) {
+			META_ERROR("cond_init failed: %s", str_GetLastError());
+			return(-1);
+		}
+		else
+			return(0);
+	}
+	inline int COND_WAIT(COND_T *cond, MUTEX_T *mutex) {
+		DWORD ret;
+		LeaveCriticalSection(mutex);
+		ret=WaitForSingleObject(*cond, INFINITE);
+		EnterCriticalSection(mutex);
+		// returns WAIT_OBJECT_0 if object was signaled; other return
+		// values indicate errors.
+		if(ret == WAIT_OBJECT_0)
+			return(0);
+		else {
+			META_ERROR("cond_wait failed: %s", str_GetLastError());
+			return(-1);
+		}
+	}
+	inline int COND_SIGNAL(COND_T *cond) {
+		BOOL ret;
+		ret=SetEvent(*cond);
+		// returns zero on failure
+		if(ret==0) {
+			META_ERROR("cond_signal failed: %s", str_GetLastError());
+			return(-1);
+		}
+		else
+			return(0);
+	}
+#endif /* _WIN32 (condition variable) */
+
+// Normalize/standardize a pathname.
+//  - For win32, this involves:
+//    - Turning backslashes (\) into slashes (/), so that config files and
+//      Metamod internal code can be simpler and just use slashes (/).
+//    - Turning upper/mixed case into lowercase, since windows is
+//      non-case-sensitive.
+//  - For linux, this requires no work, as paths uses slashes (/) natively,
+//    and pathnames are case-sensitive.
+#ifdef linux
+#define normalize_pathname(a)
+#elif defined(_WIN32)
+inline void normalize_pathname(char *path) {
+	char *cp;
+
+	META_DEBUG(8, ("normalize: %s", path));
+	for(cp=path; *cp; cp++) {
+		if(isupper(*cp)) *cp=tolower(*cp);
+		if(*cp=='\\') *cp='/';
+	}
+	META_DEBUG(8, ("normalized: %s", path));
+}
+#endif /* _WIN32 */
+
+// Indicate if pathname appears to be an absolute-path.  Under linux this
+// is a leading slash (/).  Under win32, this can be:
+//  - a drive-letter path (ie "D:blah" or "C:\blah")
+//  - a toplevel path (ie "\blah")
+//  - a UNC network address (ie "\\srv1\blah").
+// Also, handle both native and normalized pathnames.
+inline int is_absolute_path(const char *path) {
+	if(path[0]=='/') return(TRUE);
+#ifdef _WIN32
+	if(path[1]==':') return(TRUE);
+	if(path[0]=='\\') return(TRUE);
+#endif /* _WIN32 */
+	return(FALSE);
+}
+
+#ifdef _WIN32
+// Buffer pointed to by resolved_name is assumed to be able to store a
+// string of PATH_MAX length.
+inline char *realpath(const char *file_name, char *resolved_name) {
+	int ret;
+	ret=GetFullPathName(file_name, PATH_MAX, resolved_name, NULL);
+	if(ret > PATH_MAX) {
+		errno=ENAMETOOLONG;
+		return(NULL);
+	}
+	else if(ret > 0) {
+		HANDLE handle;
+		WIN32_FIND_DATA find_data;
+		handle=FindFirstFile(resolved_name, &find_data);
+		if(INVALID_HANDLE_VALUE == handle) {
+			errno=ENOENT;
+			return NULL;
+		}
+		FindClose(handle);
+		normalize_pathname(resolved_name);
+		return(resolved_name);
+	}
+	else 
+		return(NULL);
+}
+#endif /* _WIN32 */
+
+// Generic "error string" from a recent OS call.  For linux, this is based
+// on errno.  For win32, it's based on GetLastError.
+inline const char *str_os_error(void) {
+#ifdef linux
+	return(strerror(errno));
+#elif defined(_WIN32)
+	return(str_GetLastError());
+#endif /* _WIN32 */
+}
+
+
+#endif /* OSDEP_H */
diff --git a/sdk/metamod/plinfo.h b/sdk/metamod/plinfo.h
new file mode 100644
index 0000000..40303ab
--- /dev/null
+++ b/sdk/metamod/plinfo.h
@@ -0,0 +1,82 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// plinfo.h - typedefs for plugin info structure
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 PLINFO_H
+#define PLINFO_H
+
+// Flags for plugin to indicate when it can be be loaded/unloaded.
+// NOTE: order is crucial, as greater/less comparisons are made.
+typedef enum {
+	PT_NEVER = 0,
+	PT_STARTUP,			// should only be loaded/unloaded at initial hlds execution
+	PT_CHANGELEVEL,		// can be loaded/unloaded between maps
+	PT_ANYTIME,			// can be loaded/unloaded at any time
+	PT_ANYPAUSE,		// can be loaded/unloaded at any time, and can be "paused" during a map
+} PLUG_LOADTIME;
+
+// Flags to indicate why the plugin is being unloaded.
+typedef enum {
+	PNL_NULL = 0,
+	PNL_INI_DELETED,		// was deleted from plugins.ini
+	PNL_FILE_NEWER,			// file on disk is newer than last load
+	PNL_COMMAND,			// requested by server/console command
+	PNL_CMD_FORCED,			// forced by server/console command
+	PNL_DELAYED,			// delayed from previous request; can't tell origin
+//only used for 'real_reason' on MPlugin::unload()
+	PNL_PLUGIN,				// requested by plugin function call
+	PNL_PLG_FORCED,			// forced by plugin function call
+	PNL_RELOAD,				// forced unload by reload()
+} PL_UNLOAD_REASON;
+
+// Information plugin provides about itself.
+typedef struct {
+	char *ifvers;				// meta_interface version
+	char *name;					// full name of plugin
+	char *version;				// version
+	char *date;					// date
+	char *author;				// author name/email
+	char *url;					// URL
+	char *logtag;				// log message prefix (unused right now)
+	PLUG_LOADTIME loadable;		// when loadable
+	PLUG_LOADTIME unloadable;	// when unloadable
+} plugin_info_t;
+extern plugin_info_t Plugin_info;
+
+// Plugin identifier, passed to all Meta Utility Functions.
+typedef plugin_info_t* plid_t;
+#define PLID	&Plugin_info
+
+#endif /* PLINFO_H */
diff --git a/sdk/metamod/reg_support.h b/sdk/metamod/reg_support.h
new file mode 100644
index 0000000..57d07c6
--- /dev/null
+++ b/sdk/metamod/reg_support.h
@@ -0,0 +1,48 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// reg_support.h - functions for "registered" cmd/cvar/msg support
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 REG_SUPPORT_H
+#define REG_SUPPORT_H
+
+#include "mreg.h"			// REG_CMD_FN, etc
+
+void meta_command_handler(void);
+void meta_AddServerCommand(char *cmd_name, REG_CMD_FN function);
+void meta_CVarRegister(cvar_t *pCvar);
+int meta_RegUserMsg(const char *pszName, int iSize);
+void meta_QueryClientCvarValue(const edict_t *player, const char *cvarName);
+
+#endif /* REG_SUPPORT_H */
diff --git a/sdk/metamod/sdk_util.h b/sdk/metamod/sdk_util.h
new file mode 100644
index 0000000..15964a9
--- /dev/null
+++ b/sdk/metamod/sdk_util.h
@@ -0,0 +1,115 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// sdk_util.h - wrapper & extension of util.h from HL SDK
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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.
+ *
+ */
+
+// Wrap util.h from SDK with ifndef/endif, to avoid problems from multiple
+// inclusions.  Dunno why Valve didn't do that in util.h themselves..
+
+#ifndef SDK_UTIL_H
+#define SDK_UTIL_H
+
+// We're not including the DBG_EntOfVars and DBG_AssertFunction routines
+// mentioned in the SDK util.h, so we're going to unset DEBUG here so that
+// we don't get "unresolved symbol" errors.
+#ifdef DEBUG
+#undef DEBUG
+#endif /* DEBUG */
+
+// Inlcude local enginecallbacks wrapper *first* so that the g_engfuncs
+// type is correct and the <enginecallback.h> header protection is already
+// defined.
+#include "enginecallbacks.h"
+
+#include <util.h>
+
+
+
+// Add overloaded ENTINDEX() version for const edict_t pointer.
+// The pfnIndexOfEdict() function takes a const edict_t pointer
+// as parameter anyway, so there is no reason why ENTINDEX()
+// shouldn't.
+inline  int ENTINDEX(const edict_t *pEdict) { 
+	return (*g_engfuncs.pfnIndexOfEdict)(pEdict);
+}
+
+
+// Also, create some nice inlines for engine callback combos.
+
+// Get a setinfo value from a player entity.
+inline char *ENTITY_KEYVALUE(edict_t *entity, char *key) {
+	char *ifbuf=GET_INFOKEYBUFFER(entity);
+	return(INFOKEY_VALUE(ifbuf, key));
+}
+
+// Set a setinfo value for a player entity.
+inline void ENTITY_SET_KEYVALUE(edict_t *entity, char *key, char *value) {
+	char *ifbuf=GET_INFOKEYBUFFER(entity);
+	SET_CLIENT_KEYVALUE(ENTINDEX(entity), ifbuf, key, value);
+}
+
+// Get a "serverinfo" value.
+inline char *SERVERINFO(char *key) {
+	edict_t *server=INDEXENT(0);
+	return(ENTITY_KEYVALUE(server, key));
+}
+
+// Set a "serverinfo" value.
+inline void SET_SERVERINFO(char *key, char *value) {
+	edict_t *server=INDEXENT(0);
+	char *ifbuf=GET_INFOKEYBUFFER(server);
+	SET_SERVER_KEYVALUE(ifbuf, key, value);
+}
+
+// Get a "localinfo" value.
+inline char *LOCALINFO(char *key) {
+	edict_t *server=NULL;
+	return(ENTITY_KEYVALUE(server, key));
+}
+
+// Set a "localinfo" value.
+inline void SET_LOCALINFO(char *key, char *value) {
+	edict_t *server=NULL;
+	char *ifbuf=GET_INFOKEYBUFFER(server);
+	SET_SERVER_KEYVALUE(ifbuf, key, value);
+}
+
+short FixedSigned16(float value, float scale);
+unsigned short FixedUnsigned16(float value, float scale);
+
+// Our slightly modified version, using an edict_t pointer instead of a
+// CBaseEntity pointer.
+void META_UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, const char *pMessage);
+
+#endif /* SDK_UTIL_H */
diff --git a/sdk/metamod/studioapi.h b/sdk/metamod/studioapi.h
new file mode 100644
index 0000000..00aff62
--- /dev/null
+++ b/sdk/metamod/studioapi.h
@@ -0,0 +1,56 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// studio.cpp - player model blending interfaces
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 STUDIOAPI_H
+#define STUDIOAPI_H
+
+#include <studio.h>		// MAXSTUDIOBONES
+
+// Typedef for Server_GetBlendingInterface() from Eric Smith on the hlcoders 
+// mailing list.
+typedef int (*GETBLENDAPI_FN) (int version,
+		struct sv_blending_interface_s **ppinterface,
+		struct engine_studio_api_s *pstudio,
+		float (*rotationmatrix)[3][4],
+		float (*bonetransform)[MAXSTUDIOBONES][3][4]);
+
+extern int mm_Server_GetBlendingInterface(int version,
+		struct sv_blending_interface_s **ppinterface,
+		struct engine_studio_api_s *pstudio,
+		float (*rotationmatrix)[3][4],
+		float (*bonetransform)[MAXSTUDIOBONES][3][4]);
+
+#endif /* STUDIOAPI_H */
diff --git a/sdk/metamod/support_meta.h b/sdk/metamod/support_meta.h
new file mode 100644
index 0000000..870b6ee
--- /dev/null
+++ b/sdk/metamod/support_meta.h
@@ -0,0 +1,148 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// support_meta.h - generic support macros
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 SUPPORT_META_H
+#define SUPPORT_META_H
+
+#include <string.h>		// strcpy(), strncat()
+#include <sys/types.h>	// stat
+#include <sys/stat.h>	// stat
+
+#include "osdep.h"		// strcasecmp, S_ISREG,
+
+void do_exit(int exitval) ATTRIBUTE(__noreturn__);
+
+// Unlike snprintf(), strncpy() doesn't necessarily null-terminate the
+// target.  It appears the former function reasonably considers the given
+// size to be "max size of target string" (including the null-terminator),
+// whereas strncpy() strangely considers the given size to be "total number
+// of bytes to copy".  Note strncpy() _always_ writes n bytes, whereas
+// snprintf() writes a _max_ of n bytes (incl the NULL).  If strncpy()
+// needs to write extra bytes to reach n, it uses NULLs, so the target
+// _can_ be null-terminated, but only if the source string would have fit
+// anyway -  in which case why not just use strcpy() instead?
+//
+// Thus, it appears strncpy() is not only unsafe, it's also inefficient,
+// and seemingly no better than plain strcpy() anyway.
+//
+// With this logic, strncpy() doesn't appear to be much of a "str" function
+// at all, IMHO.
+//
+// Strncat works better, although it considers the given size to be "number
+// of bytes to append", and doesn't include the null-terminator in that
+// count.  Thus, we can use it for what we want to do, by setting the
+// target to zero-length (NULL in first byte), and copying n-1 bytes
+// (leaving room for the null-termiator).
+//
+// Why does it have to be soo haaard...
+
+// Also note, some kind of wrapper is necessary to group the two
+// statements into one, for use in situations like non-braced else
+// statements.
+
+// Technique 1: use "do..while":
+#if 0
+#define STRNCPY(dst, src, size) \
+	do { strcpy(dst, "\0"); strncat(dst, src, size-1); } while(0)
+#endif
+
+// Technique 2: use parens and commas:
+#if 0
+#define STRNCPY(dst, src, size) \
+	(strcpy(dst, "\0"), strncat(dst, src, size-1))
+#endif
+
+// Technique 3: use inline
+inline char *STRNCPY(char *dst, const char *src, int size) {
+	strcpy(dst, "\0");
+	return(strncat(dst, src, size-1));
+}
+
+// Renamed string functions to be clearer.
+inline int strmatch(const char *s1, const char *s2) {
+	if(!s1 || !s2) 
+		return(0);
+	else 
+		return(!strcmp(s1, s2));
+}
+inline int strnmatch(const char *s1, const char *s2, size_t n) {
+	if(!s1 || !s2) 
+		return(0);
+	else 
+		return(!strncmp(s1, s2, n));
+}
+inline int strcasematch(const char *s1, const char *s2) {
+	if(!s1 || !s2) 
+		return(0);
+	else 
+		return(!strcasecmp(s1, s2));
+}
+inline int strncasematch(const char *s1, const char *s2, size_t n) {
+	if(!s1 || !s2) 
+		return(0);
+	else 
+		return(!strncasecmp(s1, s2, n));
+}
+
+inline int old_valid_file(char *path) {
+	char *cp;
+	int len, ret;
+	cp = (char *) LOAD_FILE_FOR_ME(path, &len);
+	if(cp && len)
+		ret=1;
+	else
+		ret=0;
+	FREE_FILE(cp);
+	return(ret);
+}
+int valid_gamedir_file(char *path);
+char *full_gamedir_path(const char *path, char *fullpath);
+
+// Turn a variable/function name into the corresponding string, optionally
+// stripping off the leading "len" characters.  Useful for things like
+// turning 'pfnClientCommand' into "ClientCommand" so we don't have to
+// specify strings used for all the debugging/log messages.
+#define STRINGIZE(name, len)		#name+len
+
+
+// Max description length for plugins.ini and other places.
+#define MAX_DESC_LEN 256
+
+
+// For various character string buffers.
+#define MAX_STRBUF_LEN 1024
+
+#endif /* SUPPORT_META_H */
diff --git a/sdk/metamod/thread_logparse.h b/sdk/metamod/thread_logparse.h
new file mode 100644
index 0000000..c1db423
--- /dev/null
+++ b/sdk/metamod/thread_logparse.h
@@ -0,0 +1,59 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+#ifdef UNFINISHED
+
+// thread_logparse.h - prototypes for thread_logparse functions
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 THREAD_LOGPARSE_H
+#define THREAD_LOGPARSE_H
+
+#include "mqueue.h"			// Queue template
+#include <osdep.h>			// THREAD_T, etc
+
+extern MLogmsgQueue *LogQueue;
+extern MFuncQueue *HookQueue;
+
+extern THREAD_T logparse_thread_id;
+
+void startup_logparse_thread(void);
+void WINAPI logparse_handler(void);
+
+event_args_t *parse_event_args(const char *logline);
+event_player_t *parse_player(char *start, int *retlen);
+char *parse_quoted(char *start, int *retlen);
+
+#endif /* THREAD_LOGPARSE_H */
+
+#endif /* UNFINISHED */
diff --git a/sdk/metamod/tqueue.h b/sdk/metamod/tqueue.h
new file mode 100644
index 0000000..8ec3a89
--- /dev/null
+++ b/sdk/metamod/tqueue.h
@@ -0,0 +1,144 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+#ifdef UNFINISHED
+
+// tqueue.h - template classes for Queue and QItem
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 TQUEUE_H
+#define TQUEUE_H
+
+#define MAX_QUEUE_SIZE	50
+
+#include "osdep.h"			// MUTEX_T, etc
+
+// Forward declarations.
+template<class qdata_t> class Queue;
+
+// Template for Queue.
+template<class qdata_t>
+class Queue {
+	private:
+	// private copy/assign constructors:
+		Queue(const Queue &src);
+		void operator=(const Queue &src);
+	protected:
+	// structs:
+		class QItem {
+			private:
+			// private copy/assign constructors:
+				QItem(const QItem &src);
+				void operator=(const QItem &src);
+			public:
+				qdata_t *data;
+				QItem *next;
+				QItem(void) :data(NULL), next(NULL) { };
+				QItem(qdata_t *dnew) :data(dnew), next(NULL) { };
+		};
+	// data:
+		int size;
+		int max_size;
+		QItem *front;
+		QItem *end;
+		MUTEX_T mx_queue;
+		COND_T cv_push;
+		COND_T cv_pop;
+	//functions
+		int MXlock(void) { return(MUTEX_LOCK(&mx_queue)); };
+		int MXunlock(void) { return(MUTEX_UNLOCK(&mx_queue)); };
+	public:
+	// constructor:
+		Queue(void);
+		Queue(int qmaxsize);
+	// functions:
+		void push(qdata_t *qadd);
+		qdata_t* pop(void);
+};
+
+
+///// Template Queue:
+
+// Queue constructor (default).
+template<class qdata_t> Queue<qdata_t>::Queue(void)
+	: size(0), max_size(MAX_QUEUE_SIZE), front(NULL), end(NULL), mx_queue(), 
+	  cv_push(), cv_pop()
+{
+	MUTEX_INIT(&mx_queue);
+	COND_INIT(&cv_push);
+	COND_INIT(&cv_pop);
+}
+
+// Queue constructor.
+template<class qdata_t> Queue<qdata_t>::Queue(int qmaxsize)
+	: size(0), max_size(qmaxsize), front(NULL), end(NULL), mx_queue(), 
+	  cv_push(), cv_pop()
+{
+	MUTEX_INIT(&mx_queue);
+	COND_INIT(&cv_push);
+	COND_INIT(&cv_pop);
+}
+
+// Push onto the queue (at end).
+template<class qdata_t> void Queue<qdata_t>::push(qdata_t *qadd) {
+	QItem *qnew;
+	MXlock();
+	while(size >= max_size)
+		COND_WAIT(&cv_push, &mx_queue);
+	qnew = new QItem(qadd);
+	end->next = qnew;
+	end=qnew;
+	size++;
+	MXunlock();
+}
+
+// Pop from queue (from front).  Wait for an item to actually be available
+// on the queue (block until there's something there).
+template<class qdata_t> qdata_t* Queue<qdata_t>::pop(void) {
+	QItem *qtmp;
+	qdata_t *ret;
+	MXlock();
+	while(!size)
+		COND_WAIT(&cv_pop, &mx_queue);
+	qtmp=front;
+	front=qtmp->next;
+	size--;
+	ret=qtmp->data;
+	delete qtmp;
+	MXunlock();
+	return(ret);
+}
+
+#endif /* TQUEUE_H */
+
+#endif /* UNFINISHED */
diff --git a/sdk/metamod/types_meta.h b/sdk/metamod/types_meta.h
new file mode 100644
index 0000000..01b14f7
--- /dev/null
+++ b/sdk/metamod/types_meta.h
@@ -0,0 +1,82 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// types_meta.h - common internal type, etc definitions
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 TYPES_META_H
+#define TYPES_META_H
+
+// Our own boolean type, for stricter type matching.
+typedef enum mBOOL {
+	mFALSE = 0,
+	mTRUE,
+} mBOOL;
+
+// Like C's errno, for our various functions; describes causes of failure
+// or mFALSE returns.
+typedef enum {
+	ME_NOERROR = 0,
+	ME_FORMAT,			// invalid format
+	ME_COMMENT,			// ignored comment
+	ME_BLANK,			// ignored blank (empty) line
+	ME_ALREADY,			// request had already been done
+	ME_DELAYED,			// request is delayed
+	ME_NOTALLOWED,		// request not allowed
+	ME_SKIPPED,			// request is being skipped for whatever reason
+	ME_BADREQ,			// invalid request for this <whatever>
+	ME_ARGUMENT,		// invalid arguments
+	ME_NULLRESULT,		// resulting data was empty or null
+	ME_MAXREACHED,		// reached max/limit
+	ME_NOTUNIQ,			// not unique (ambigious match)
+	ME_NOTFOUND,		// in find operation, match not found
+	ME_NOFILE,			// file empty or missing
+	ME_NOMEM,			// malloc failed
+	ME_BADMEMPTR,		// invalid memory address
+	ME_OSNOTSUP,		// OS doesn't support this operation
+	ME_DLOPEN,			// failed to open shared lib/dll
+	ME_DLMISSING,		// symbol missing in lib/dll
+	ME_DLERROR,			// some other error encountered calling functions from dll
+	ME_IFVERSION,		// incompatible interface version
+	ME_UNLOAD_UNLOADER,	// tried to unload unloader
+	ME_UNLOAD_SELF,		// tried to unload self
+} META_ERRNO;
+extern META_ERRNO meta_errno;
+
+#define RETURN_ERRNO(retval, errval) \
+	do { meta_errno=errval; return(retval); } while(0)
+
+#define RETURN_LOGERR_ERRNO(errargs, retval, errval) \
+	do { META_ERROR errargs ; meta_errno=errval; return(retval); } while(0)
+
+#endif /* TYPES_META_H */
diff --git a/sdk/metamod/vdate.h b/sdk/metamod/vdate.h
new file mode 100644
index 0000000..b35c0a0
--- /dev/null
+++ b/sdk/metamod/vdate.h
@@ -0,0 +1,44 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// vdate.h - compile-time version date
+
+/*
+ * Copyright (c) 2001-2003 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 VDATE_H
+#define VDATE_H
+
+extern char const *COMPILE_TIME;
+
+extern char const *COMPILE_TZONE;
+
+#endif /* VDATE_H */
diff --git a/sdk/metamod/vers_meta.h b/sdk/metamod/vers_meta.h
new file mode 100644
index 0000000..28efed6
--- /dev/null
+++ b/sdk/metamod/vers_meta.h
@@ -0,0 +1,55 @@
+// vi: set ts=4 sw=4 :
+// vim: set tw=75 :
+
+// vers_meta.h - version info, intended to be common among DLLs distributed
+// with metamod.
+
+/*
+ * Copyright (c) 2001-2005 Will Day <willday@hpgx.net>
+ *
+ *    This file is part of Metamod.
+ *
+ *    Metamod 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.
+ *
+ *    Metamod 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 Metamod; 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 VERS_META_H
+#define VERS_META_H
+
+#ifndef OPT_TYPE
+# if defined(_MSC_VER) && defined(_DEBUG)
+#  define OPT_TYPE		"msc debugging"
+# elif defined(_MSC_VER) && defined(NDEBUG)
+#  define OPT_TYPE		"msc optimized"
+# else
+#  define OPT_TYPE		"default"
+# endif /* _MSC_VER */
+#endif /* not OPT_TYPE */
+
+#define VDATE			"2006-04-17"
+#define VVERSION		"1.19"
+#define RC_VERS_DWORD	1,19,0,0	// Version Windows DLL Resources in res_meta.rc
+
+#endif /* VERS_META_H */